Authentication Required

diff --git a/.eslintrc.js b/.eslintrc.js index f757116..f80a614 100644 --- a/.eslintrc.js +++ b/.eslintrc.js @@ -23,7 +23,9 @@ module.exports = { 'rankings': 'writable', 'newRankings': 'writable', 'consensus': 'writable', - 'leaderStats': 'writable' + 'leaderStats': 'writable', + 'dao': 'writable', + 'daoMaster': 'writable' }, 'parserOptions': { 'ecmaVersion': 2020 diff --git a/.gitignore b/.gitignore index 96735ea..c965805 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,4 @@ node_modules -package-lock.json npm-debug.log .idea keys @@ -9,4 +8,6 @@ bin dump genesis apidoc -.DS_Store \ No newline at end of file +.DS_Store +.commandcode +opencode.bash \ No newline at end of file diff --git a/Dockerfile b/Dockerfile index dc5ec68..42ebc7b 100644 --- a/Dockerfile +++ b/Dockerfile @@ -3,8 +3,10 @@ LABEL "project.home"="https://github.com/nannal/avalon" RUN git clone git://github.com/skzap/avalon WORKDIR /avalon RUN npm install +RUN mkdir -p /avalon/genesis /avalon/dump && chown -R node:node /avalon EXPOSE 6001 EXPOSE 3001 +USER node ENV DB_URL 'mongodb://localhost:27017' ENV DB_NAME 'avalon' ENV NODE_OWNER 'default user' diff --git a/README.md b/README.md index 2574313..22500bc 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ #### Dependencies * [MongoDB](https://mongodb.com) -* [NodeJS](https://nodejs.org/en/download/) **v14/16** (LTS) +* [NodeJS](https://nodejs.org/en/download/) **≥24.0.0** (LTS) * [ntpd](https://linux.die.net/man/8/ntpd) or any NTP alternative for your system. ntpd comes pre-installed on most linux distributions ## Install and run an Avalon node for Linux @@ -24,29 +24,38 @@ The `start.sh` shows the list of available environment variables you can set to * Run `scripts/start.bat` * Note: to restore a genesis.zip file you may need to download the [mongo databasetools](https://www.mongodb.com/try/download/database-tools?tck=docs_databasetools) and put the mongorestore.exe binary into your main directory. +## Tests + +A small smoke-test suite covers recent behavioral fixes (including admin auth). Run it with: + +``` +node test/audit-fixes.js +``` + ## [Syncing your node](./doc/syncing-your-node.md) ## [Become a leader and produce blocks](./doc/leader-101.md) ## [Debian 10 quick install procedure](./doc/debian-10.md) +## [Public testnet guide (multi-operator)](./doc/public-testnet.md) ## Get helped -We have a discord channel dedicated to node owners (aka leaders), where you can get support to get set up. Join [discorg.gg/dtube](https://discord.gg/dtube) and go to `DTube Chain -> #leader-candidates` +We have a Discord channel dedicated to node owners (aka leaders), where you can get support to get set up. Join [discord.gg/QsBnrwqsSV](https://discord.gg/QsBnrwqsSV) and go to `DTube Chain -> #leader-candidates` ## Using Avalon Once you have a node running, there are many ways to interact with Avalon: ### With the CLI tool -You can use the CLI tool to transact with Avalon. Simply try `node src/cli --help` or `node src/cli --help` for a full help. +You can use the CLI tool to transact with Avalon. Simply try `node src/cli.js --help` or `node src/cli.js --help` for full help. -### Using Javalon -[Javalon](https://www.npmjs.com/package/javalon) is the javascript wrapper for Avalon's API. Working on both browser and nodejs. +### Using Javalon2 +[javalon2](https://www.npmjs.com/package/javalon2) is the JavaScript wrapper for Avalon's API. It works in both browser and Node.js. ### HTTP API Avalon's API uses 100% JSON. The GET calls will allow you to fetch the public information which is already available through the d.tube UI. Examples: -* Account data: /account/:username, i.e https://avalon.d.tube/account/rt-international -* Video data: /content/:username/:link i.e. https://avalon.d.tube/content/rongibsonchannel/QmdjVMdeTtTEy1CJTDbtjuaiRKMP6H364Dv4n7FsWGpnPH +* Account data: `/account/:username`, e.g. `http://localhost:3001/account/rt-international` or `https://api.avalonblocks.com/account/rt-international` +* Video data: `/content/:username/:link`, e.g. `http://localhost:3001/content/rt-international/QmdjVMdeTtTEy1CJTDbtjuaiRKMP6H364Dv4n7FsWGpnPH` ### Full list of API endpoints [https://docs.google.com/spreadsheets/d/1ORoHjrdq5V5OkTChijTUOEYRzTujVXTzCyNYt-ysVhw/edit?usp=drive_web&ouid=109732502499946497195](https://docs.google.com/spreadsheets/d/1ORoHjrdq5V5OkTChijTUOEYRzTujVXTzCyNYt-ysVhw/edit?usp=drive_web&ouid=109732502499946497195) @@ -54,12 +63,12 @@ Examples: This lists all the available API endpoints for Avalon. We also have recommended security practises if you want to open your node's API to the world. You can do it easily with nginx and [avalon-nginx-config](https://github.com/dtube/avalon-nginx-config). ### Sending Transactions to the network (POST /transact) -Once you have an account and balance (if you don't, you can create one on [https://signup.d.tube](https://signup.d.tube), your account will start generating bandwidth and voting power (respectively the bw and vt fields in your account data). You can consume those resources by transacting. +Once you have an account and balance (create one with `node src/cli.js account ` or through a DTube frontend), your account will start generating bandwidth and voting power (respectively the `bw` and `vt` fields in your account data). You can consume those resources by transacting. Every transaction will have a bandwidth cost, calculated based on the number of bytes required for the storage of your transaction inside a block. Certain transaction types will require you to spend voting power, such as publishing a content, voting or tagging a content. -To transact, you need to use the /transact POST call of the Avalon API. All the examples here are for the CLI tool, but the same can be achieved with [Javalon](https://npmjs.org/javalon) in Javascript. +To transact, you need to use the /transact POST call of the Avalon API. All the examples here are for the CLI tool, but the same can be achieved with [javalon2](https://www.npmjs.com/package/javalon2) in JavaScript. Necessary for all transactions: * *key*: your private key @@ -77,7 +86,7 @@ node src/cli.js vote-leader -K 5DPwDJqTvMuykHimmZxThfKttPSNLzJjpbNtkGNnjPAf -M a ``` #### Unvote a leader -* *target*: the node owner to approve +* *target*: the leader to remove your vote from ``` node src/cli.js vote-leader -K -M @@ -97,26 +106,26 @@ node src/cli.js transfer -K HkUbQ5YpejWVSPt8Qgz8pkPGwkDrMn3XECd4Asn3ANB3 -M bob #### Add a post / Commenting * *link*: a short string to be used as the index of the content -* *parent_author*: the username of the author of the parent post -* *parent_link*: the link of the parent post -* *json*: arbitrary json input. example: `{"string":"aye", array:[1,2,3]}` +* *parent_author*: the username of the author of the parent post (use empty string `''` for a top-level post) +* *parent_link*: the link of the parent post (use empty string `''` for a top-level post) +* *json*: arbitrary JSON input. example: `{"string":"aye","array":[1,2,3]}` * *tag*: arbitrary short text content -* *weight* : the number of vote tokens to spend on this vote +* *vt*: the number of vote tokens to spend on this vote ``` -node src/cli.js comment -K -M +node src/cli.js comment -K -M ``` #### Vote a post * *link*: the link of the post to vote on * *author*: the username of the author to vote on -* *weight*: the number of vote tokens to spend on this vote +* *vt*: the number of vote tokens to spend on this vote * *tag*: arbitrary short text content ``` -node src/cli.js vote -K -M +node src/cli.js vote -K -M ``` #### Edit your user json object -* *json*: arbitrary json input. example: `{"string":"aye", array:[1,2,3]}` +* *json*: arbitrary JSON input. example: `{"string":"aye","array":[1,2,3]}` ``` node src/cli.js profile -K -M ``` @@ -146,13 +155,29 @@ sleep 5 curl -H "Content-type:application/json" --data @tmptx.json http://localhost:3001/transact ``` +### Admin Authentication + +Several privileged endpoints (such as `/mineBlock`, `/recover`, `/debug` and `/logs`) are protected by bearer/query tokens. Avalon checks the following environment variables: `ADMIN_TOKEN`, `LOG_ADMIN_TOKEN`, `MINE_TOKEN`, `DEBUG_TOKEN`, `RECOVER_TOKEN`. + +* When **no** admin token is configured, these endpoints accept plain requests. This keeps unconfigured development nodes usable without a login popup. +* When one or more tokens are configured, requests must include the token either as a query parameter (`?token=`) or as an `Authorization: Bearer ` header. HTML browsers receive a login popup; API clients receive a `401` JSON error. + +Set the relevant token in `scripts/start.sh` (or your environment) before exposing the API to the public. + ### Other POST Calls #### Mine Block -Will force the node to try to produce a block even if it's unscheduled. Useful for block #1 and working on development +Will force the node to try to produce a block even if it's unscheduled. Useful for block #1 and for development. + +With no admin token configured: +``` +curl http://localhost:3001/mineBlock +``` + +With an admin token configured: +``` +curl http://localhost:3001/mineBlock?token=$ADMIN_TOKEN ``` -curl http://localhost:3001/mineBlock -``` #### Add peer Manually force connection to a peer without having to restart the node @@ -162,6 +187,10 @@ curl -H "Content-type:application/json" --data '{"peer" : "ws://localhost:6001"} ### Data storage +### JSON content limits + +Arbitrary JSON in transactions (`comment`, `profile`, `playlistJson`, etc.) is validated against a size limit (`jsonMaxBytes` in `src/config.js`, currently 60,000 bytes) and a bandwidth cap (`bwMax`, currently 64,000 bytes). Object keys cannot contain `.` or `$`. This is enough for rich metadata such as multi-resolution video descriptors or provider links, but keep payloads compact to avoid transaction rejection. + ### MongoDB Avalon saves the state of the chain into mongodb after each block. You can easily query mongodb directly to get any data you want, that wouldn't be provided by the API itself. ``` @@ -182,4 +211,4 @@ curl http://localhost:9200/avalon.accounts/_search?q=satoshi ``` Please refer to Elastic Search documentation for more complex queries. -D.Tube runs a public Elastic Search mirror of the current testnet on https://search.d.tube +> Note: there is no guaranteed public Elastic Search mirror for the current network; run your own `monstache` instance if you need full-text indexing. diff --git a/doc/consensus-offline-leaders-plan.en.md b/doc/consensus-offline-leaders-plan.en.md new file mode 100644 index 0000000..320c626 --- /dev/null +++ b/doc/consensus-offline-leaders-plan.en.md @@ -0,0 +1,988 @@ +# Implementation Plan — Offline / Unresponsive Leaders without Accidental Forks + +**Status:** design proposal (implementation plan) — **parameters approved 2026-10-26** (§10) +**Scope:** Avalon consensus (`src/chain.js`, `src/consensus.js`, `src/config.js`, `src/p2p.js`, `src/leaderStats.js`) +**Baseline analysed:** `feat/auto-force-finalize` @ `e15c1f0` (= PR #2, tag `v2.0.2` + the P2P catch-up fix; the `new_net` release line without Economy Fork `#13330000`) +**Target release:** `v2.1.0` (Layer S) and `v2.2.0` (Layer H) — see §8 +**Language:** English (project convention for `doc/`) + +--- + +## 0. Executive summary + +Avalon already has a *crash-tolerant proposal layer* (a scheduled leader plus a fallback +ladder built from the most recent block producers) and a *voting finality layer* (2/3+ +quorum over the active leaders). The chain therefore does **not** stop when one leader +disappears: the next block is produced by the previous miner after one extra block time. + +What is missing is everything around that mechanism: + +* the skip is **not attested**: `missedBy` is set by the producer, never validated, never + used by consensus; +* the **finality quorum adapts to the wrong set**: `activeLeaders()` is derived from the + *last 10 produced blocks* and only checks that a name is in the current shuffle, never + that its node is alive. A leader that stops producing keeps being counted until 10 blocks + have been produced without it — and production is strictly sequential (`minerWorker` is + called from `addBlock` only), so **two leaders dying inside the same 10-block span leave a + denominator of 5 and a threshold of 4 with only 3 signers, and the window can never drain: + permanent halt** (force finalisation cannot help, it needs the same quorum). When the + deaths are far enough apart to fall out of the window the chain does survive, but silently + at the weakest safe configuration (3-of-5, with no record of who is missing); +* **force-finalisation can still pick different blocks on different nodes** (local candidate + set + local clock ⇒ vote splitting / "fork risk" log path); +* **nothing punishes or replaces a dead leader**: a leader with fewer votes (`node_appr`) + can never take the slot of a higher-ranked dead one, because the rotation set is fixed + to the top `L` accounts by `node_appr`. + +This plan introduces a **deterministic turn ladder** derived only from block data, an +**on-chain skip attestation** (`skips[]`, additive to the block), **digest-based absence +accounting**, **soft jailing without slashing**, **automatic replacement of a dead leader by +the next-ranked (lower-vote) leader**, and a **zero-fee wake-up** built from an *existing* +transaction type. + +Two layers, because they have very different compatibility envelopes: + +| Layer | Content | Consensus change | Old nodes | +|---|---|---|---| +| **S** (soft fork) | `skips[]` attestation, deterministic force-finalize, absence accounting, adaptive quorum, grace margin, future-block queue, wake-up | **none** — new nodes are *stricter*/different only in local policy; block validity rules are unchanged | keep validating the chain, never block the upgraded majority | +| **H** (hard fork, height-gated) | standby promotion into the rotation (lower-vote leader replaces a jailed one), canonical leader-set ordering, strict `skips` validation | **yes** — leader-set computation changes | must be upgraded before the activation height (flag day) | + +Layer H is the part that literally delivers *"a lower-vote leader takes the place of a +higher-vote leader whose node is not working"*. Layer S is a prerequisite and can be +shipped and battle-tested while the chain is still halted; Layer H should be activated on +the same maintenance window because the network is already halted at block **13,320,067**. + +**Non-goals:** slashing, permanent key removal, reward changes, changes to public +key/signature structures, transaction fee changes, reorg/fork-choice support. + +--- + +## 1. Requirements and compliance matrix + +| # | Requirement | How it is satisfied | Proof | +|---|---|---|---| +| R1 | **Deterministic on-chain, no fork.** No node may deactivate keys from local timeouts/latency; penalties and turn-skips must be state transitions derived from the chain (emptied slots recorded in the next validated block). | Skip sets are a pure function of `(schedule epoch, previous block miners, block metadata)`; jail/streak state is recomputed from `skips[]` + `miner` only; quorum eligibility (`lastTurn`) is chain-derived. The only wall-clock element is the `haltBreaker` (§6.3.1, enabled at `H_S` after drill G11), which changes *when* a node accepts an already-produced block — never validity, keys, or state. | §5.3, §6.1, §6.3, Appendix A; tests `skip-attestation`, `jail-state`, `quorum`, chaos G5/G6/G11 | +| R2 | **Maximum backward compatibility.** Minimal block-schema and state-DB changes; a soft-fork path where old nodes keep validating the main chain; no change to keys/signatures; only leader election / round-robin touched. | `skips[]` is an *optional additive* field covered by the existing V2 hash; old nodes hash it identically and ignore its semantics. No DB migration; one optional derived table. Leader-set changes are isolated in Layer H. | §4.1, §4.2, §8.1, §8.5; downgrade test G9 | +| R3 | **Minimal punitivity (soft jailing).** No slashing, no permanent removal; suspension only after `N` on-chain-proven consecutive missed turns; low-friction return (heartbeat or automatic). | Jail = *eligibility* flag only (rotation demotion / quorum exclusion). Balance, stake, keys untouched. `N = 30` consecutive turns (≈ 9 min). Auto-expiry after `J = 200` blocks with exponential re-jail backoff, plus a zero-fee heartbeat. | §6.2, §7.1, §7.2 | +| R4 | **Lower-vote leader replaces a dead higher-vote leader.** | `activeLeaderSet(h)` = top `L` by `(node_appr desc, name asc)` minus jailed, backfilled from a standby pool (`leaderStandbys`); the schedule epoch is regenerated every `L` blocks from that set, so the promoted leader gets *priority 1* slots. Un-jail reinstates the original leader; permanent retirement stays a governance action (`DISAPPROVE_NODE_OWNER`). | §6.4, §6.7; testnet G4 | + +**Hard truth about R2 + R4:** the two cannot both hold in the strict sense. Reassigning a +*priority-1* slot to a node that has never produced cannot be expressed inside the old +validation envelope (proof in §3.3, Lemma 2). R2 is therefore satisfied by Layer S +(fully soft) and by Layer H's *staged roadmap*, while R4 is delivered by Layer H. +The plan is explicit about which rule is active at which height. + +--- + +## 2. Baseline: how Avalon chooses and finalises blocks today + +### 2.1 Code map (verified against `e15c1f0`) + +| Mechanism | Location | Behaviour | +|---|---|---| +| Scheduled leader | `src/chain.js` `minerSchedule()` ~L691 | `rand = last 6 hex chars of block.hash`; `miners = generateLeaders(true,false,L,0)` (top `L` by `node_appr`); deterministic Fisher–Yates shuffle; padded with repeats if `< L` leaders. Recomputed **every `L` blocks** (`block._id % L === 0`, ~L294). | +| Priority-1 (scheduled) | `chain.js` ~L559 | `shuffle[(h-1) % L].name === miner` | +| Fallback ladder | `chain.js` ~L565 | the miner of block `h-1` has priority 2, `h-2` → 3, … up to `L`; `minerPriority = recency index + 1` | +| Early check | `chain.js` ~L585 | reject if `ts(h) - ts(h-1) < minerPriority · blockTime`; env escape hatch `SKIP_EARLY_CHECK_BLOCKS` (default `3889058` — a past incident) | +| Skip bookkeeping | `chain.js` ~L145 | producer sets `missedBy = shuffle[(h-1)%L].name` **only** when it is not the scheduled leader; never validated (`chain.js` ~L534 even misses the `cb(false)`) | +| Block hash | `chain.js` ~L812 | V2 = `sha256(JSON.stringify(block − {hash, signature}))` ⇒ **any extra field is hashed by old and new nodes identically** | +| Consensus rounds | `consensus.js` ~L170-330 | 2 rounds (`config.consensusRounds`), every leader pre-commits every valid block it sees, then commits | +| Quorum | `consensus.js` ~L74-95 | `max(3, floor(activeLeaders·2/3)+1)`, `+1` for observers; `activeLeaders()` = current shuffle + recent producers that are in the current shuffle | +| Force finalize | `consensus.js` ~L387-643 | local timer (`Date.now()`), local winner (earliest `ts`, then lowest hash), broadcast all candidates, collect votes, backoff `600/1200/2400/4800 ms`, **halt if no quorum** (`forceFinalizeFallback=false`) | +| Message signing | `consensus.js` ~L644 | consensus votes are valid only if the signer is in the **current** shuffle | +| Sync | `p2p.js` `recover()` ~L469 | forward-only, by height; a node that is behind adds blocks **without** consensus rounds | +| Leader index | `leaderStats.js` | optional (`LEADER_STATS=1`) counters `produced/missed` from `missedBy` | + +### 2.2 Failure modes found (F) + +| Id | Failure | Consequence | Fixed in | +|---|---|---|---| +| **F1** | `missedBy` is unvalidated and single-valued (only the scheduled leader, not the intermediate backups) | no trustworthy absence data; a leader can be blamed by anyone; no basis for jailing | S | +| **F2** | Quorum denominator comes from the last 10 *produced* blocks and ignores liveness (`getActiveLeaderKey` only checks membership in the current shuffle) | 2 leaders dying within the same 10-block span ⇒ denominator 5, threshold 4, 3 signers, frozen window ⇒ **permanent halt**; deaths far enough apart ⇒ silent 3-of-5 operation with no record of who is absent | S (§6.3) | +| **F3** | Force-finalize ranks candidates locally (`timestamp`, `hash`) and each node votes for *its own* local best | vote splitting despite agreement on the rules; the `forceFinalizeFallback` path can fork | S | +| **F4** | `maxDrift = 200 ms`: a block whose timestamp is 200 ms ahead of the local clock is **rejected forever**, and the sender is penalised via `recordBlockFailure` | clock-skew-induced divergence / peer banning | S | +| **F5** | `SKIP_EARLY_CHECK_BLOCKS` (hard-coded height `3889058`) is a binary escape hatch for a past early-block incident | a validation rule that can only be bypassed by an env var, not by chain evidence | S (grace margin + attested skips), H (strict) | +| **F6** | `generateLeaders()` sorts by `node_appr` only, over `Object.keys(cache.leaders)` (Mongo natural order) | **ties are not canonical**: two nodes can compute different top-`L` sets, hence different schedules | H (canonical order), S (diagnostics) | +| **F7** | `minerSchedule(block)` is recomputed at **restart** from the *current* `cache.accounts` (`main.js` ~L137-144) instead of the state at that block | a restart after an approval/disapproval in the current epoch yields a different schedule than the running nodes → priority-1 blocks at 3 s are rejected until the next epoch | S (persist the epoch schedule) | +| **F8** | No reorg / fork-choice; `recover()` is forward-only | any real divergence requires manual truncation (`scripts/auto_resolve_halt.sh`) or a DB restore | mitigated (deterministic ranking + quorum intersection), §5.5 | +| **F9** | A dead leader can never be replaced by the next-ranked (lower-vote) leader | the rotation keeps one slot per round permanently degraded (3 s → 6.5 s), and the dead account keeps its slot indefinitely | H | + +### 2.3 Two lemmas that shape the design + +**Lemma 1 (soft-fork envelope).** +A change is *soft* iff every block accepted by an upgraded node is also accepted by a +non-upgraded node. In `isValidNewBlock`, the only consensus-relevant checks are: field +types, `_id`/`phash` continuity, `timestamp ≤ localNow + 200 ms`, miner ∈ +`{scheduled} ∪ {last L producers}` with `gap ≥ priority·blockTime`, then tx execution and +hash/signature. Anything that only *adds fields to the block* is inside the envelope, +because the V2 hash is computed over the received object (extra fields included) and old +nodes never inspect `missedBy`/`skips`. Anything that adds a **new rejection reason on +data an old producer emits** is *not* soft and must be height-gated after universal +upgrade. + +**Lemma 2 (priority-1 reassignment requires a hard fork).** +Let `X = S(h)` be a leader that has been excluded from the new rotation and `Y` the +promoted standby. Under the old rules, `Y` is authorised only if `Y = S_old(h)` (it is +not: `S_old(h) = X`) or `Y` produced one of the last `L` blocks (a promoted standby has +produced **none**). Hence `Y`'s block is `unauthorized miner` for every old node. +Even if `Y` had produced recently, its recency index is `L-1`, so the old rule requires a +gap of `L·blockTime = 15 s`, while a priority-1 takeover is 3 s. **Conclusion:** the +rotation replacement (R4) is a height-gated consensus change; everything else is not. + +--- + +## 3. Design overview + +### 3.1 The turn ladder (canonical, chain-derived) + +For every height `h = head + 1`, every node computes the same ordered candidate list: + +``` +schedule(h) = the shuffle of the current epoch // regenerated every L blocks +S(h) = schedule(h)[(h - 1) mod L] // priority 1 +ladder(h) = [ S(h) ] // p = 0 + ∪ [ miner(h-1), miner(h-2), … ] // p = 1, 2, … (dedup, skip self) + ∪ [ standbys… ] // Layer H only, p = |above| … +candidate at position p may produce at ts(h-1) + (p+1)·blockTime (+ grace if p ≥ 1) +``` + +This is *exactly* the priority rule the chain already enforces (Lemma 1); the plan only +makes it explicit, attestable and extensible. The ladder is a function of block history +only — no node-level liveness probe, no timer, no ping. + +### 3.2 Layer S vs Layer H + +| | Layer S — `v2.1.0` | Layer H — `v2.2.0` | +|---|---|---| +| `skips[]` in blocks | written, validated in **warn** mode | written, **strictly** validated | +| Force-finalize | deterministic ranking + candidate fetch | unchanged | +| Absence accounting | on-chain, per leader | same | +| Quorum | jail-aware (`E`) | same | +| Rotation | **unchanged** | top-`L` minus jailed + standbys | +| New tx types | none | none | +| Activation | all heights ≥ resume | `h ≥ H_standby` (first epoch boundary) | +| Old nodes | follow the chain; may lag, never block | must be upgraded (flag day) | + +### 3.3 Parameters (canonical values; consensus parameters live in `config.history`) + +| Name | Default | Meaning | +|---|---|---| +| `skipRecording` | `true` @ resume | producers must set `skips` (array, may be empty) | +| `skipStrict` | `false` → `true` @ `H_strict` | reject blocks whose `skips` ≠ canonical | +| `jailMissThreshold` (`N`) | `30` turns | consecutive proven misses → soft jail (≈ 9 min at 3 s) | +| `quorumEligibility` | `lastTurn` | a leader leaves the quorum denominator once its most recent scheduled turn was demonstrably skipped on-chain (no timer); `streak` (M turns) is available as the conservative alternative | +| `haltBreaker` | `true` @ `H_S` (after drill G11) | enable the recovery round of §6.3.1 | +| `haltBreakerMs` | `(L+2)·blockTime` = 21 s | no finalised block for this long ⇒ engage the recovery round | +| `haltBreakerQuorum` | `remaining` | the recovery round requires the **unanimity of the remaining eligible set** (≥ 3) | +| `jailBlocks` (`J`) | `200` blocks | first jail duration (≈ 12 min) | +| `jailBackoffMax` | `4` | re-jail durations `J·{1,2,4}` | +| `leaderStandbys` (`R`) | `5` | standby pool size (Layer H) | +| `standbyEnabled` | `false` → `true` @ `H_standby` | Layer H rotation replacement | +| `skipGraceMs` | `500` | extra wait for substitutes (producer-side only) | +| `quorumMin` | `3` | absolute floor for the adaptive quorum | +| `pendingBlockMaxMs` | `2·L·blockTime` = 30 s | max hold time for a future-dated block | +| `heartbeatTxType` | `18` (`ENABLE_NODE`) | wake-up envelope (existing tx) | + +`L`, `blockTime`, `consensusRounds`, `maxDrift` are unchanged (`5`, `3000`, `2`, `200`). + +--- + +## 4. Phase 1 — State machine and data structures + +### 4.1 Block schema: one optional additive field + +```js +// src/chain.js +class Block { + constructor(index, phash, timestamp, txs, miner, missedBy, dist, burn, signature, hash, skips) { + … + if (missedBy) this.missedBy = missedBy // kept: old indexers, /block docs, leaderStats + if (skips && skips.length) this.skips = skips // NEW: ordered, distinct, length ≤ L + R + … + } +} +``` + +* **Write**: in `mineBlock()` replace the single + `if (scheduler !== NODE_OWNER) newBlock.missedBy = scheduler` with + `newBlock.skips = ladder.slice(0, p)` and `newBlock.missedBy = newBlock.skips[0]` + (keeps every existing consumer working). +* **Hash**: nothing to do — `calculateHashForBlock` V2 hashes the whole object; old and new + nodes compute the same digest from the same JSON. `calculateHashV1` (legacy + `blockHashSerialization: 1`) is untouched and remains valid for historical blocks. +* **Persist**: `blocks.appendBlock()` / Mongo `insertOne()` are schema-less (BSON / + document). No migration, no index change. +* **Read**: `blocks.read()` / `findOne()` return the field as-is; `/block/:number` exposes + it automatically (add the apidoc line). +* **Bounds**: `Array.isArray`, `length ≤ L + R`, every entry a valid account name + (`accountMinLength..accountMaxLength`), no duplicates, `miner ∉ skips`. + +Estimated diff: **~15 lines** in `chain.js`, 1 line of apidoc. + +### 4.2 Derived state: `src/leaderHealth.js` (no DB migration) + +A new in-memory module, rebuilt from `chain.recentBlocks` at startup and updated in +`addBlock()` / `rebuildState()` next to `leaderStats.processBlock(block)`. + +```js +{ + // per leader + produced, missed, lastProduced, + streak, // consecutive proven missed turns + jail: { active, untilBlock, level, lastJailBlock, probation }, + lastSkip: { height, position, jailedAtTheTime } +} +``` + +* Feed: `block.miner`, `block.skips` (fallback `[block.missedBy]` for pre-activation + blocks), and the schedule epoch that was in force at that height. +* Rebuild cost: one pass over `recentBlocks` (≤ `ecoBlocks` = 9 600) — negligible, no I/O. +* Persistence: **none required**. The optional `leaderStats` extension (`LEADER_STATS=1`, + collection `leaders`) can store `jailed/until/level/streak` for the dashboard; it is + derived and rebuildable. +* This module never mutates `accounts`, `balances`, `node_appr`, or keys. + +### 4.3 One small optional persistence addition (fixes F7) + +At each epoch boundary (`block._id % L === 0`) persist the *computed* epoch schedule: + +```js +state: { _id: 'schedule:', leaders: [names…], set: [names…], jailSnapshot: {...} } +``` + +* Written once every `L` blocks (≈ 15 s), pruned to the last 2 epochs. +* Read by `main.js` `startDaemon()` instead of recomputing from the live cache ⇒ a + restarted node recomputes the **same** schedule as the running nodes. +* Derived, rebuildable, ignored by old nodes ⇒ **no compatibility impact**. If the + document is missing (old DB), fall back to today's recomputation and log a warning. +* Can be disabled with `SCHEDULE_PERSIST=0` (diagnostic). + +### 4.4 Config and activation + +All consensus-affecting parameters go into `src/config.js` `history` (same mechanism as +`forceFinalize` @ 13 325 000; note that the `100: { forceFinalize: true }` entry currently +present in the S4 worktree is a **testnet-only local patch, not in `v2.0.2`**): + +```js +// Layer S — additive field + local policy, safe at any height (ship enabled by default) +H_S = 13325000 // ≈ 5 000 blocks after the resume block 13 320 067 +{ skipRecording: true, skipStrict: false, quorumMin: 3, quorumEligibility: 'lastTurn', + jailMissThreshold: 30, jailBlocks: 200, jailBackoffMax: 4, skipGraceMs: 500, + haltBreaker: true, haltBreakerMs: 21000 } // off-switch: env HALT_BREAKER=0 + +// Layer H — strict validation + rotation replacement (flag day, all nodes upgraded) +H_H = 13400000 // first epoch boundary applied: ceil(H_H / L) · L +{ skipStrict: true, standbyEnabled: true, leaderStandbys: 5, + canonicalLeaderOrder: true } +``` + +All values above are the **approved** ones (§10); the alternatives are recorded there. + +`config.read(blockNum)` already applies entries cumulatively in numeric order and logs +`Hard Fork #`; `chain.addBlock()` reloads the config after every block. The +**effective** height of a rotation change is the first epoch regeneration at or after +`H_H`, i.e. `ceil(H_H / L) · L` — deterministic and independent of restarts (the epoch +document makes it explicit). + +### 4.5 API / observability + +| Endpoint | Change | +|---|---| +| `/block/:n` | documents `skips` | +| `/schedule` | adds `epoch`, `set`, `standbys`, `jailed` (additive keys; existing `shuffle` untouched) | +| `/leader/:acc` | adds `streak`, `jailed`, `jailUntil`, `jailLevel` (additive) | +| `/allminers` | adds `rank`, `eligible`, `jailed` (additive) | +| **new** `/consensus` | `{ head, epoch, set, standbys, ladder, eligible, quorum, jail[], lastSkips[] }` — the single page an operator looks at during an incident | +| **new** `/debug/statehash` | `sha256(derived state + last 100 block hashes)` for cross-node determinism checks (testnet chaos tests, §8.3) | + +### 4.6 Files touched (Phase 1) + +`src/chain.js` (Block, mineBlock, minerSchedule, generateLeaders), `src/leaderHealth.js` +(new), `src/config.js`, `src/main.js` (startup), `src/http/consensus/index.js` (new), +`src/http/schedule/index.js`, `src/http/leader/index.js`, `src/http/allminers/index.js`, +`src/http/index.js`, `src/leaderStats.js`, `doc/api-indexing.md`. + +--- + +## 5. Phase 2 — "Skipped turn" determination + +### 5.1 The rule + +> A turn at height `h` is **proven skipped** for candidate `X` iff a *finalised* block at +> `h` records `X ∈ skips`, where `skips` is exactly the prefix of `ladder(h)` that precedes +> the actual miner, and the block satisfied the gap rule for its own position. + +No timer, no timeout, no liveness probe. The evidence is inside the block, and the block is +final because it is in the chain. + +### 5.2 Producer algorithm (`chain.js`) + +```js +const ladder = chain.leaderLadder(height) // §3.1, pure +const p = ladder.indexOf(process.env.NODE_OWNER) +if (p === -1) return // not my turn and not a backup +const dueAt = prev.timestamp + (p + 1) * config.blockTime + + (p > 0 ? config.skipGraceMs : 0) // producer-side only +// wait until dueAt (existing minerWorker), then: +newBlock.skips = ladder.slice(0, p) // ← attested empty slots +newBlock.missedBy = newBlock.skips[0] // ← legacy field +``` + +`minerWorker()` changes from "find my recency index" to "find my ladder index" (same +numbers, one function, one test). The `+500 ms` grace applies **only to substitutes**: a +healthy scheduled leader keeps the 3 s cadence, while a leader whose clock is 0–500 ms slow +is no longer pre-empted by an eager backup (anti-griefing, §6.6). Because the rule is a +*minimum* gap, a longer wait is always compatible with old nodes. + +### 5.3 Validator algorithm (`isValidNewBlock`) + +**Unchanged (always, both layers):** +`_id`/`phash` continuity, field types, `gap ≥ (p+1)·blockTime` with `p` derived exactly as +today, `miner` authorised (`p` exists). + +**Layer S (`skipStrict: false`):** if `skips` is present, recompute the canonical prefix +and log a warning on mismatch; **never reject**. This is the canary: a mismatch means two +nodes disagree on the ladder (F6/F7), and operators must see it *before* Layer H. + +**Layer H (`skipStrict: true`):** +1. `skips` must be present (even `[]`). +2. `skips` must equal `ladder(h).slice(0, p)` exactly (order, content, distinct, no miner). +3. `missedBy`, when present, must equal `skips[0]`. +4. Jail-administrative skips are part of the canonical prefix (the jailed leader is still + in `ladder(h)` until its last production falls out of the `L`-block window); the + accounting in §6.1 distinguishes them. + +Old nodes perform none of 1–4, so Layer H is a genuine hard fork and is height-gated. + +### 5.4 Timestamps, drift, and the pending queue (fixes F4) + +`maxDrift` stays 200 ms (changing it is not needed and would be a config divergence), but +the **reaction** changes: + +| Situation | Today | New | +|---|---|---| +| `ts > now + maxDrift` | `logr.error('timestamp from the future')`, `cb(false)`, `recordBlockFailure(sender)` | keep the block in `consensus.pending[height]`, re-check at `ts - maxDrift - now` (bounded by `pendingBlockMaxMs = 30 s`), **no peer penalty**; drop silently after the bound | +| `ts` too old (`< prev.ts`) | invalid | unchanged | +| vote freshness | `±2·blockTime` around the local clock | `±(consensusRounds+2)·blockTime` (consensus votes are not block content; a wider window removes skew-induced vote dropping without weakening anti-replay, which is provided by the `processed` dedupe) | + +This removes the last **local-clock** input from block validity, satisfying R1. + +### 5.5 Deterministic force-finalisation (fixes F2/F3) + +Force finalisation is kept as the **safety net** but becomes view-synchronising instead of +view-guessing: + +1. **Rank is chain-derived, not local.** `rank(candidate) = (p, timestamp, hash)` with `p` + from `ladder(candidate._id)`. Every node computes the same rank for the same block. +2. **Fetch missing candidates.** New P2P message `t:8 FF_FETCH {height, hashes[]}` answered + with `t:9 FF_BLOCK {block}` (unknown types are ignored by old nodes — the `switch` has + no `default`, so this is P2P-backward-compatible). The receiver validates the block via + `consensus.round(0, …)` and only then feeds it to `_resolveForceFinalize`. +3. **Monotone votes.** A node may change its FF vote only towards a strictly better rank + (never away). This prevents oscillation and closes the "each node votes for its own + local winner" split. +4. **Same winner everywhere.** Because `rank` is a total order over the union of candidates, + all nodes that can see the candidates converge on the same winner; the quorum is then + about *availability*, not about *choice*. +5. **No quorum ⇒ halt, never fork.** `forceFinalizeFallback` stays `false` (default). The + halt is now rare (only when candidates are unavailable, i.e. network partition), and it + is *recoverable* by the existing `auto_resolve_halt.sh`/runbook without truncation in + most cases. +6. **Timer anchoring.** Keep the current chain-time anchor + (`latestBlock.timestamp + blockTime · (L + rounds + 2)`), but the timer only *triggers* + the protocol; no state transition depends on when it fires. + +### 5.6 Why this cannot fork + +* Two different blocks at the same height can exist, but finality still requires `q` distinct + signers (quorum intersection): with `q = 4` of `L = 5`, two disjoint quorums would need + `4 + 4 = 8` signatures from at most `5 + b` signers, i.e. `b ≥ 3` colluding keys; with the + degraded `q = 3 / E = 3` configuration it would need **all** remaining signers. +* The skip attestation changes **no** validity rule in Layer S and only *adds* rejection + reasons for upgraded producers in Layer H (a producer running the new code always + satisfies them, because it derives the same ladder from the same chain). +* A non-upgraded producer in Layer H can at worst stall *itself*: its block lacks `skips`, + the upgraded quorum rejects it, and the node then catches up via `recover()` (which + bypasses voting). It cannot drag the chain onto a different branch. + +--- + +## 6. Phase 3 — Soft jailing and absence counting + +### 6.1 Absence accounting (pure function of the chain) + +```js +// applied in chain order; `jailStateAt(h-1)` is known because it was derived from h-1 +processBlock(block) { + for (const name of skipsOf(block)) { // canonical order + if (name === miner(block)) continue // impossible by rule, defensive + if (jailedAt(name, block._id - 1)) continue // administrative skip, not a miss + streak[name]++ + missed[name]++ + lastSkip[name] = block._id + if (streak[name] >= N) jail(name, block._id) + } + const m = block.miner + streak[m] = 0 // any production clears the streak + jailState[m].active = false // producing clears the jail (soft) + jailState[m].level = 0 + produced[m]++ +} +``` + +* `skipsOf(block)` = `block.skips` if present, else `block.missedBy ? [block.missedBy] : []` + — this makes historical blocks (pre-activation) usable for the rebuild without a + migration. +* Only *consecutive* misses matter (reset on production) — no "30 misses over 3 months". +* A miss is counted **only** from a finalised block, and only when the producer had a + legitimate window (gap rule) — the two conditions that make it "proven on-chain". +* No balance, `node_appr`, key or account field is touched. **No slashing.** + +### 6.2 Jail state machine + +``` +ACTIVE --(N consecutive misses)--> JAILED(level=1, until=h+J) +JAILED --(h = until)-------------> PROBATION (back in the set, must produce in its next turn) +PROBATION --(produces)-----------> ACTIVE (level=0) +PROBATION --(misses its turn)----> JAILED(level=min(level+1, jailBackoffMax), until=h+J·2^level) +JAILED --(valid heartbeat)-------> ACTIVE (level=0) §7.2 +``` + +| Transition | Trigger | Deterministic? | +|---|---|---| +| JAILED | `streak ≥ N` (`N = 30` turns ≈ 9 min) | yes (block data) | +| Expiry | `head ≥ until` | yes (block height, not wall clock) | +| Re-jail | probation turn missed | yes | +| Wake-up | tx type 18 from the leader's account inside a finalised block | yes (block content) | +| Clear | any block produced by the leader | yes | + +### 6.3 Effect 1 — adaptive quorum (liveness, Layer S) + +Today there are **two** formulas, and both are keyed on a set that includes absent leaders: +`tryNextStep` uses `floor(2·active/3) + 1` (min 3, `+1` for observers, `~L79`) and +`_getQuorumThreshold` uses `min(4, max(ceil(2·active/3), 3))` (`~L413`); they coincide for +`active ≤ 5` but live in two places. `active = activeLeaders().length`, where +`activeLeaders()` = the scheduled leader + miners of the last `2L = 10` blocks that are in +the current shuffle. `getActiveLeaderKey()` only checks *membership*, never liveness, so a +dead leader keeps its place in the denominator for as long as the chain keeps producing +without it — and it stops producing exactly when the quorum is lost. That asymmetry is the +whole problem (F2). + +**Eligibility (no timer, pure chain data).** A leader is *eligible* unless its most recent +scheduled turn in the current epoch was demonstrably skipped: + +``` +lastTurn(X) = max{ h ≤ head : S(h) = X } // from the epoch schedule (chain data) +absent(X) = (miner(lastTurn(X)) ≠ X) // its turn was taken by a backup +eligible(h) = { X ∈ epoch set : ¬absent(X) } +E = |eligible(h)| +q = min(4, max(3, E)) // one helper, both paths +q_observer = min(q + 1, |epoch set|) +``` + +Rationale for `lastTurn` instead of a streak counter: a single hiccup is harmless +(`E = 4 ⇒ q = 4`, unchanged), while two leaders that missed their most recent turn give +`E = 3 ⇒ q = 3`, which is the smallest change that restores liveness. It is exact, it needs +no new state, and it is evaluated *at finalisation time* on data already in the chain. + +**Safety.** A fork needs two disjoint signer sets of size `q`; with `b` Byzantine extra votes +that requires `2q ≤ E + b`. + +| Offline leaders | E | q | Fork requires | Chain survives? | +|---|---|---|---|---| +| 0 | 5 | 4 | `b ≥ 3` → 3 of 5 colluding | yes | +| 1 | 4 | 4 | `b ≥ 4` → all 4 remaining colluding | yes (4 online = quorum) | +| 2 | 3 | 3 | `b ≥ 3` → all 3 remaining colluding | **yes (new)** | +| 3 | 2 | 3 | unreachable | no — deterministic halt | + +So the adaptive quorum never lowers the bar below "the whole remaining eligible set must +collude": at full strength a fork needs 3 of 5, in the degraded states it needs *all* the +remaining signers. At `E = 4` this is strictly *stronger* than today (today `active = 4` +yields `q = 3`, i.e. 2 colluding signers would already be enough). `quorumMin` stays `3` +(= unanimity of the remaining three), which is exactly what makes `q = 3` safe. + +**Why a different `q` cannot fork.** Quorum is not part of block validity. A node with a +higher `q` finalises later and then catches up through `recover()`, which bypasses voting. +Two nodes can only disagree if they finalise *different blocks of the same height*, and that +is prevented by §5.5 (synchronised candidate set + deterministic rank + single monotone +vote), not by the threshold value. + +**Vote counting** must be de-duplicated by name (`Set`), and `tryNextStep` / +`_getQuorumThreshold` must call the same helper so the two paths can never diverge again. + +#### 6.3.1 The one time-triggered element: recovery round (`haltBreaker`) + +`lastTurn` only sees misses that were *recorded*. If two leaders die within the same round, +the chain freezes at `head` before any block can record their absence — and nothing can be +recorded afterwards, because production is strictly sequential (`minerWorker(block)` is +called from `addBlock(block)` only, `chain.js` ~L296). No deterministic rule can break this +freeze: a node that has stopped answering is, by definition, not represented in the chain +until someone else produces a block, and nobody can produce one. + +Therefore — and this is the **only** place where wall-clock time enters the design — a node +that has seen no finalised block for `haltBreakerMs = (L+2)·blockTime = 21 s` starts a +*recovery round* for `head+1`: + +1. Collect candidates for `head+1` for `2·blockTime` (normal gossip, plus `FF_FETCH`). +2. Rank them deterministically (§5.5) and pick the winner `W`. +3. Sign **one** vote for `W` (single, monotone: never for two different blocks at a height). +4. Finalise `W` when it carries the signature of **every** member of the remaining eligible + set (`unanimity`, `|signers| = E_remaining ≥ 3`), and only then. + +Why this is fork-safe: after step 1 all nodes that can communicate share the *same* +candidate set, hence compute the same `W`; honest nodes cast **one** vote, for `W`. A +competing block `W'` therefore needs `E_remaining` signatures that nobody honest can supply, +i.e. it needs **all** remaining signers to be dishonest. If unanimity is not reached, the +node does **not** finalise: it alerts and halts (R2: halt rather than fork), and an operator +restarts the missing node. + +This changes *when* a node accepts a block, **never** *which* block is valid, and it never +touches keys, balances, `node_appr` or the rotation — so it is compatible with R1, while +being honest that it is a local liveness policy, not a consensus rule. **Approved** (§10.7): +enabled at `H_S`, after the testnet drill G11 has passed. Because it is local policy it also +has an environment off-switch (`HALT_BREAKER=0`), so it can be suspended during an incident +without a release. + +### 6.4 Effect 2 — rotation replacement by lower-vote leaders (R4, Layer H) + +This is the mechanism requested explicitly: **an account with fewer votes (`node_appr`) +takes the slot of a higher-vote account whose node is not producing.** + +``` +activeLeaderSet(h) = + sort(all accounts with pub_leader and node_appr > 0, + by node_appr DESC, then name ASC) // canonical, fixes F6 + remove accounts with jail.active at h + take the first L // priority set = rotation +standbyPool(h) = the next R non-jailed accounts // promotion queue +``` + +* The set is evaluated **at each epoch regeneration** (`block._id % L === 0`), from the + derived state at that block ⇒ all nodes compute the same set. +* `minerSchedule()` shuffles `activeLeaderSet` (seeded by the epoch block hash, unchanged); + a promoted standby therefore becomes `S(h)` with **priority 1 (3 s)** — a real + replacement, not a last-resort backup. +* Padding: if the eligible set has fewer than `L` names, `minerSchedule` already repeats + names to keep the period `L` (index math, `(h-1) % L`, stays untouched — deliberately, to + minimise churn). +* The demoted leader stays a legitimate *backup* while it is still in the last `L` + producers, so a node that comes back cannot be blocked from producing an emergency block; + this preserves the "no permanent removal" property. +* `ladder(h)` in Layer H also gains the `standbyPool` tail (`p = L+1 …`), so even a + simultaneous failure of the whole top-`L` rotation can be covered after ~21–30 s without + any local decision. +* **Reinstatement:** when the jail expires, the original leader (still higher `node_appr`) + returns to `activeLeaderSet` at the next epoch, and the standby goes back to the pool. + To avoid churn, the re-jail duration doubles each time (`J, 2J, 4J`, capped). +* **Permanent retirement** is *not* automatic: the existing governance transaction + `DISAPPROVE_NODE_OWNER` (type 2) lowers the dead leader's `node_appr`, after which the + standby outranks it permanently. Jailing is soft by design; hard removal remains a + governance decision. + +### 6.5 Safety analysis (Layer H) + +| Risk | Analysis | Mitigation | +|---|---|---| +| Standby promotion forks old nodes | Lemma 2 | height-gated, universal upgrade (§8.2) | +| Set changes mid-epoch | schedule is only regenerated at epoch boundaries; jail state evaluated once per epoch for the *set*, but the quorum uses the live `lastTurn` eligibility | documented; epoch schedule persisted (§4.3) | +| Quorum reduced to `q = 3` | a fork needs 3 signatures of 3 remaining ⇒ **all** remaining signers dishonest; `2q > E + b` in every reachable state (§6.3) | `quorumMin: 4` switch + alert when `E < 4` | +| `haltBreaker` finalises a block another node would not | it only fires on the synchronised candidate set with a single monotone vote, and requires unanimity of the remaining eligible set (§6.3.1); it can be disabled | enabled after drill G11; env off-switch `HALT_BREAKER=0` | +| Ping-pong between a returning leader and its standby | one stutter per un-jail cycle | exponential re-jail backoff | +| A fast standby repeatedly pre-empts a slow scheduled leader | producer grace (+500 ms) + NTP requirement + canonical order | §6.6, runbook check | +| Whole rotation jailed | `standbyPool` tail in the ladder | §6.4 | +| Set becomes empty | `minerWorker` already halts with a fatal log | alert, manual intervention (unchanged) | + +### 6.6 Anti-griefing + +* **Grace margin** (`skipGraceMs = 500`): substitutes wait an extra 500 ms, so a scheduled + leader with sub-second clock skew is never recorded as missing. Only producers respect + it (old nodes see a *longer* gap, which is always valid). No cost in the healthy path. +* **Clock hygiene** is an operational requirement (NTP/chrony) and will be checked by the + runbook; the pending-block queue (§5.4) removes the hard failure when it slips. +* **Blame needs a finalised block**; nobody can mark a leader absent with an unsigned + message. A single malicious producer cannot jail anyone alone: it needs a finalised block + whose canonical prefix contains the victim, and a finalised block needs a quorum. +* **No economic effect**: jail changes eligibility only. There is nothing to steal by + jailing a competitor, which keeps the incentive to game it at zero. + +### 6.7 Worked example (simulated with the real rule, `L = 5`, `blockTime = 3000`) + +Leader `B` is offline; `A, C, D, E` are healthy. Ladder positions and timing: + +| height | S(h) | producer | p | t (s) | `skips` | +|---|---|---|---|---|---| +| 1 | A | A | 0 | 3.0 | `[]` | +| 2 | **B** | A | 1 | 9.5 | `["B"]` | +| 3 | C | C | 0 | 12.5 | `[]` | +| 4 | D | D | 0 | 15.5 | `[]` | +| 5 | E | E | 0 | 18.5 | `[]` | +| 6 | A | A | 0 | 21.5 | `[]` | +| … | | | | | | +| 2·k | **B** | A | 1 | … | `["B"]` | + +* One missing leader costs **+3.5 s per round** (18.5 s instead of 15 s): the chain keeps + running, no halt, no fork. +* `B` reaches `streak = 30` after **30 rounds ≈ 555 s ≈ 9.25 min** → jailed (`J = 200` + blocks). +* Layer H from the next epoch: the set becomes `A, C, D, E` (+ top standby), the round + returns to **15 s**, and `B`'s slot is gone. `B` returns → heartbeat → reinstated at the + next epoch. +* Two missing leaders (`B`, `D`): round = 22 s; as soon as one block records both skips, + `absent(B) ∧ absent(D)` ⇒ `E = 3`, `q = 3` ⇒ the chain continues with `A, C, E` (no + timer, no waiting window). If the two die **in the same round**, no block can record it + first: that is the freeze of §6.3.1, broken by the recovery round (unanimity of `A, C, E`). +* Three missing leaders (`B, D, E`): `E = 2 < quorumMin` ⇒ deterministic halt, alert, no + fork. Recovery = bring one node back or restart it (§7). +* Today (for comparison): the same two deaths inside the 10-block window keep the + denominator at 5 / threshold 4 with 3 signers ⇒ **permanent halt**. + +--- + +## 7. Phase 4 — Wake-up + +### 7.1 Automatic (default, no operator action) + +Jail expiry at `until = h + J·2^level` is a pure height comparison. The node is +reinstated into `activeLeaderSet` (Layer H) or back into the expected-voter set (Layer S) +with a **probation**: one missed turn re-jails it with doubled duration. Nothing to sign, +nothing to send. Works even if the operator lost the account key. + +### 7.2 Heartbeat transaction (fast path, zero fee, existing tx type) + +**Design constraint discovered in the code:** a zero-amount `TRANSFER` (type 3) is +**invalid** — `transfer.js` calls `validate.integer(amount, canBeZero=false, canBeNegative=false)`. +A new transaction type would be a hard fork. Therefore the heartbeat uses an **existing** +type that old nodes already execute: + +> **`ENABLE_NODE` (type 18) re-sent with the account's current `pub_leader` key.** +> `enableNode.js` performs `$set: { pub_leader: }` (idempotent) and +> `cache.addLeader()` (idempotent). No fee, no balance change, no `node_appr` change, +> no reward effect. Old nodes execute it exactly as today. + +New nodes add one rule in `leaderHealth.processBlock()`: a type-18 tx from account `X` +inside a finalised block **immediately** clears `X.jail` and `X.level` (deterministic: +time of effect = the containing block, not the receive time). + +Requirements and operational notes: +* The tx must be signed by a key authorised for type 18 on that account. If the node only + holds the leader key, authorise it once with `NEW_KEY`/`ACCOUNT_AUTHORIZE` + (`types: [18]`) — or run the heartbeat from the account owner's wallet. +* Idempotent and self-only: an account can only wake itself up, so there is no spam vector + against others. +* If the operator never sends it, the automatic expiry still works (at most `J` blocks of + delay). + +**Alternative envelope** (same properties, if type 18 is undesirable for a given operator): +`USER_JSON` (type 6) with `json.node.hb = ""`. It is a plain profile +update for old nodes. Do **not** use a 0-value transfer. + +### 7.3 Operator procedure (goes into the runbook) + +1. On restart, the node rebuilds `leaderHealth` from `recentBlocks`; `/consensus` shows + `jailed: true, until: ` immediately (no waiting for gossip). +2. Wait until the node is caught up (`/` head == peers' head). +3. Send the heartbeat (CLI `node scripts/heartbeat.js --account --key `). +4. Verify `/consensus` → `jailed: false`, and that the node appears in `/schedule` at the + next epoch. +5. If the node is unhealthy, do nothing: the automatic expiry handles it, and the standby + keeps the slot until then. + +### 7.4 Determinism check + +`leaderHealth` is a fold over finalised blocks: restart, replay, crash recovery and +`rebuildState` all produce the same state. Heartbeat effects are applied at block +application time (same place as `leaderStats`), never on message receipt. The +`/debug/statehash` endpoint exposes it for verification. + +--- + +## 8. Phase 5 — Deployment and network backward compatibility + +### 8.1 Stage plan + +| Stage | Release | Content | Activation | Upgrade requirement | +|---|---|---|---|---| +| **S0** | `v2.1.0` | `skips[]` write + warn-mode validation, deterministic FF + fetch, pending-block queue, grace margin, `leaderHealth`, `/consensus`, `/debug/statehash`, schedule persistence | immediately (all heights) | none (additive) | +| **S1** | `v2.1.x` | adaptive quorum (`q = min(4, max(3, E))` on `lastTurn` eligibility), jail accounting active, wake-up, `haltBreaker` | `H_S = 13 325 000` | leaders (quorum is local policy) | +| **H1** | `v2.2.0` | strict `skips` validation | `H_strict = 13 400 000` | **5/5 leaders + all public validators** | +| **H2** | `v2.2.0` | `activeLeaderSet` + standby promotion + canonical order | `H_standby = 13 400 000` (effective `ceil(H/5)·5`) | same flag day | + +Why this order: S0/S1 can be observed for weeks without any risk of rejecting an old +producer; H1/H2 are the only rules that can reject a block an old node would accept, and +they are bundled with the feature that actually needs them. + +### 8.2 Readiness gates (hard, not aspirational) + +Before `H_strict`/`H_standby`: + +1. **Version census**: every current epoch member and every standby reports the new + `version` string in `NODE_STATUS` (`p2p.js` already carries it). Gate: 5/5 leaders and + 100 % of known public validators. Exception: a leader already jailed/absent is excluded + from the census (it cannot produce anyway). +2. **Schedule agreement**: `/debug/statehash` and `/schedule` identical across all upgraded + nodes for ≥ 1 000 consecutive blocks (catches F6/F7 *before* H). +3. **Warn-mode clean**: zero `skips mismatch` warnings for ≥ 1 000 blocks. +4. **Fallback drill**: on testnet, run G1–G12 (§8.3) with the exact release artifact, + including G11 (`haltBreaker` recovery) and G12 (conservative halt). +5. **Rollback artifact**: pre-`H` DB snapshot + `blocks.bson` copy on every node, per the + existing runbook §6. + +If any gate fails, `H_strict`/`H_standby` are postponed by editing the heights **before** +the release is deployed. Heights in `config.history` are immutable once passed, so the +decision must be made before the flag day (this mirrors the `13 325 000` pattern already +used for `forceFinalize`/`consensusSigVersion`). + +### 8.3 Test matrix + +**Unit (`node test/.js`, assert-only, no DB):** + +| File | Cases | +|---|---| +| `test/skip-attestation.js` | ladder for `L = 1…7`; dedupe; duplicate schedule names; missing `recentBlocks` at genesis; canonical prefix for `p = 0…L`; `skips` tampering rejected in strict / warned in soft; `gap` boundary (`+1 ms`, `-1 ms`); grace only for `p ≥ 1` | +| `test/jail-state.js` | streak counting, reset on production, administrative skips, `N` boundary, expiry, probation re-jail, backoff cap, heartbeat clears jail, replay determinism (same blocks, shuffled arrival order) | +| `test/quorum.js` | `E = 0…5`, `q` monotonicity, `q = 4` with 1 absent, `q = 3` with 2 absent, `lastTurn` eligibility (skip recorded / not recorded / epoch boundary), observers' `+1` capped, duplicate-name dedupe, hostile `activeLeaders` (sybil) | +| `test/force-finalize.js` (extend) | rank total order, fetch path, monotone votes, no-quorum halt, `fromNow` guard, retry cap (existing tests stay green) | +| `test/standby.js` | canonical `(node_appr, name)` ordering, promotion at the epoch boundary, reinstatement, empty pool, padding when `< L` | + +**Integration (`docker/testnet`, 5 leaders + 2 standbys, always with +`-f docker-compose.yml -f docker-compose.migrate.yml`):** + +| Id | Scenario | Expected | +|---|---|---| +| G1 | 1 leader down 60 blocks | chain continues at 3.5 s avg, `skips` correct, no jail | +| G2 | 1 leader down 200 blocks | jailed at 30 turns, `E=4/q=4`, no halt; heartbeat → back in the next epoch | +| G3 | 2 leaders down 400 blocks | jailed, `E=3/q=3`, chain continues (documented trade-off); both return, rotation restored | +| G4 | top-5 leader down 200 blocks (Layer H) | standby #6 enters at the next epoch, produces at 3 s, all nodes accept; original returns → reinstated | +| G5 | 3/2 partition for 100 blocks | majority finalises; minority resyncs via `recover()`; **no divergent height** (`statehash` equal) | +| G6 | clock skew ±5 s on two nodes | blocks held in `pending` then accepted; no rejection, no peer ban, no divergence | +| G7 | equivocation (same key on two nodes) | deterministic rank picks one block; no fork; both blocks logged | +| G8 | force-finalize with asymmetric views | fetch path converges on the same winner; no halt | +| G9 | one **old** node during S1 / during H1 | S1: follows the chain normally; H1: stalls, resyncs automatically, never forks | +| G10 | all 5 leaders down | chain halts deterministically (no fork), recovers when ≥ 3 return | +| G11 | 2 leaders killed in the *same* round (`docker kill` both) | freeze is detected after 21 s; recovery round converges on one candidate, finalised with the unanimity of the remaining 3; **no fork**, chain resumes without operator action | +| G12 | 2 leaders killed, `HALT_BREAKER=0` (off-switch) | deterministic halt + alert (no fork); restarting one node resumes the chain — this is the conservative fallback behaviour with the breaker disabled | + +**Chaos / soak:** replay 100 000 blocks with a random 0–3 leaders offline, random clock +skew, random restarts; assert identical `/debug/statehash` on all nodes at every checkpoint; +assert `jailed` transitions match the expected deterministic timeline. + +### 8.4 Cutover during the current halt (operational advantage) + +The network is halted at block **13 320 067** (since 2026-06-27) and `forceFinalize` is +inactive until **13 325 000**. That makes the upgrade the *cheapest possible* flag day: + +1. All operators upgrade to `v2.1.x` **before** the resume. Because the chain is halted, + there is no "mixed version" window at all: the resume block is produced by new code. +2. `skipRecording` is active from the first resumed block. Old nodes can still be started + and will hash/index the new blocks correctly (downgrade path). +3. S1 activates at `H_S = 13 325 000` (≈ 5 000 blocks after resume ≈ 5 h at 3 s): enough + time to observe the new fields, fast enough to matter. +4. H1/H2 at `H_strict = 13 400 000` (≈ 80 000 blocks ≈ 3 days after resume): a full + observation window with warn-mode clean and the version census complete. +5. `v2.0.x` remains runnable read-only: it will follow the chain, which is exactly the R2 + property we want to be able to demonstrate (and it is test G9). + +Note: the `100: { forceFinalize: true }` entry present in the S4 worktree is a testnet +patch; it must not ship. + +### 8.5 Rollback + +| Situation | Action | Data loss | +|---|---|---| +| S0/S1 misbehaves | redeploy the previous tag; the chain is unchanged (no new validity rule), old code ignores `skips` | none | +| H1/H2 must be undone **after** activation | full coordinated rollback: stop all nodes, restore the pre-`H` DB + `blocks.bson` snapshot, redeploy the old tag (runbook §6) | blocks produced after `H` are lost (bounded by the snapshot age) | +| Split detected | **do not truncate automatically**; `auto_resolve_halt.sh` is last-resort only, and it now refuses repeated truncation | per script | + +Because Layer H is height-gated and its gate is evaluated before the release ships, the +"rollback after activation" case is an operational failure, not an expected path. The +recommended posture (same as PR #2's `forceFinalizeFallback: false`) is: **halt rather than +fork**. + +### 8.6 Risk register + +| Risk | Likelihood | Impact | Mitigation | +|---|---|---|---| +| A standby is promoted while its node is actually broken | low | one wasted slot per round until `N` misses | ladder fallback; jail cascade | +| Quorum `q = 3` under a Byzantine participant | low | a fork needs **all** remaining signers to be dishonest (3 of 3); with 1–2 Byzantine among them the honest majority still votes one block | `quorumMin: 4` switch; alert on `E < 4` | +| Operators skip the heartbeat and wait `J` | medium | ~12 min of rotation loss | automatic expiry is the default; alerting | +| `node_appr` tie order differs across nodes (F6) | **high today** | schedule mismatch, priority-1 stalls | canonical order in H; `/debug/statehash` gate in S | +| Restart recomputes a different schedule (F7) | medium | priority-1 stalls after restart | epoch schedule persistence | +| Disk/BSON growth from `skips` | negligible | ~50–100 B/block | — | +| Docker testnet bootstrap DB wiped by missing `-f docker-compose.migrate.yml` | known | test-only | documented in the test scripts | + +--- + +## 9. Implementation checklist (file by file) + +| # | File | Change | Phase | +|---|---|---|---| +| 1 | `src/chain.js` | `Block.skips`; `leaderLadder()`; `minerWorker` uses ladder + grace; `mineBlock` writes `skips`/`missedBy`; `isValidNewBlock` warn/strict; `minerSchedule`/`generateLeaders` canonical order + `activeLeaderSet` + standby pool; persist epoch schedule | 1-3 | +| 2 | `src/leaderHealth.js` | **new** — streaks, jail state machine, heartbeat rule, derived rebuild | 1-3 | +| 3 | `src/consensus.js` | unified `_getQuorumThreshold` with `E`; deterministic `rank`; `FF_FETCH`/`FF_BLOCK` handling; monotone votes; `haltBreaker` recovery round (§6.3.1); pending-block queue; vote freshness window | 1-2 | +| 4 | `src/p2p.js` | `MessageType.FF_FETCH = 8`, `FF_BLOCK = 9` (old nodes ignore unknown types); no peer penalty for future-dated blocks | 2 | +| 5 | `src/config.js` | `history` entries `H_S`, `H_strict`/`H_standby` with the parameters of §3.3 | 1 | +| 6 | `src/main.js` | load the persisted epoch schedule; warn when missing | 1 | +| 7 | `src/leaderStats.js` | persist `jailed/until/level/streak` when `LEADER_STATS=1` | 1 | +| 8 | `src/http/consensus/index.js` | **new** `/consensus` | 1 | +| 9 | `src/http/debug/statehash.js` | **new** `/debug/statehash` | 1 | +| 10 | `src/http/schedule|leader|allminers` | additive fields + apidoc | 1 | +| 11 | `scripts/heartbeat.js` | **new** — send `ENABLE_NODE` with the current leader key | 3 | +| 12 | `test/skip-attestation.js`, `test/jail-state.js`, `test/quorum.js`, `test/standby.js` | **new**, assert-only | 1-3 | +| 13 | `test/force-finalize.js`, `test/audit-fixes.js` | extend, keep green | 2 | +| 14 | `docker/testnet/*` | G1–G12 scripts + `statehash` comparison | 4 | +| 15 | `doc/mainnet-deployment-and-rollback.md`, `doc/migration-runbook-no-econs.en.md` | new stages, gates, heartbeat procedure | 4 | +| 16 | `doc/leader-101.md` | explain soft jail / standbys to operators | 4 | + +Estimated effort: **S0+S1 ≈ 10–14 engineering days** (incl. tests), **H1+H2 ≈ 6–8 days**, +**testnet soak ≈ 5 days**. Critical path: `leaderHealth` + `chain.js` ladder, then the +quorum unification, then the standby set. + +`eslint` baseline is `1 pre-existing error` (`src/http/auth/index.js:86`), 244 warnings — keep +it unchanged. + +--- + +## 10. Decisions — approved 2026-10-26 + +All parameters below are **decided** and are the values referenced by §3.3, §4.4, §6 and §8. +The alternatives are kept for the record (re-opening a decision requires a new height entry +in `config.history`, or the environment off-switch where noted). + +| # | Parameter | **Approved** | Why / alternative rejected | Reversible? | +|---|---|---|---|---| +| 10.1 | `quorumMin` | **3** | at `E = 3` the quorum is the unanimity of the remaining three, so a fork needs all of them colluding; rejecting `4` because it would halt the chain with 2 dead leaders | yes, new height entry | +| 10.2 | `N` (`jailMissThreshold`) | **30 turns** (≈ 9 min) | long enough to survive a reboot/deploy, short enough to free the slot the same hour; the quorum no longer depends on `N` (it uses `lastTurn`) | yes, new height entry | +| 10.3 | `J` (`jailBlocks`) | **200 blocks** (≈ 12 min), `jailBackoffMax = 4` | first jail short, then `200/400/800` to stop ping-pong with a node that keeps flapping | yes, new height entry | +| 10.4 | `leaderStandbys` (`R`) | **5** | covers a mass failure of the whole top-`L`; standbys never produce or vote unless promoted, so the steady-state cost is only a longer ladder tail (max takeover 30 s) | yes, new height entry | +| 10.5 | `skipStrict` (Layer H) | **strict** at `H_strict` | makes `skips[]` consensus-relevant, so a schedule divergence is rejected immediately instead of producing silent gaps; gated by §8.2 (5/5 leaders + all public validators) | no, after the height (rollback = DB restore) | +| 10.6 | Activation heights | **`H_S = 13 325 000`**, **`H_strict = H_standby = 13 400 000`** | ≈ 5 h and ≈ 3 days after the resume block 13 320 067; the rotation change applies at `ceil(H/5)·5`. Confirm the numbers with the 5 leader operators before the release ships | no, after the height | +| 10.7 | `haltBreaker` | **on** at `H_S`, `haltBreakerQuorum = remaining` (never below 3) | recovers a same-round double death automatically in 21 s; fork-safe because it needs unanimity of the survivors on a synchronised candidate set. **Gate: testnet drill G11 must pass first.** Local policy ⇒ off-switch `HALT_BREAKER=0` | yes, environment switch | + +**Consequences for the release plan** + +* Only 10.5 and 10.6 are irreversible once the height is passed: they are the two items that + must be frozen before the `v2.1.x` artifact is published (§8.2). +* 10.1–10.4 are consensus-visible parameters but can be changed later through a new entry in + `config.history` at a future height — no client change required. +* 10.7 is local policy: it can be turned off/on per node at any time without any height. + +**Still open (not part of this plan's scope):** the operator-side items tracked separately — +the `v2.0.3` tag after PR #2, the `README.md` diff review, the IT runbook mirror commit, and +the S4 worktree patch (`100: { forceFinalize: true }`, widened `masterDaoTxs`) which must +never ship. + +--- + +## Appendix A — Reference algorithms (pseudo-code) + +```js +// ---------- shared, pure ---------- +function scheduleEpoch(h) { // epoch start is the last multiple of L + return Math.floor(h / config.leaders) * config.leaders +} + +function activeSet(h) { // Layer H; Layer S returns generateLeaders(L) + const all = accountsWithLeaderKey() // cache.accounts + .filter(a => a.node_appr > 0) + .sort((a, b) => b.node_appr - a.node_appr || (a.name < b.name ? -1 : 1)) + const alive = all.filter(a => !leaderHealth.isJailed(a.name, h)) + return { + set: alive.slice(0, config.leaders), + standbys: alive.slice(config.leaders, config.leaders + config.leaderStandbys) + } +} + +function ladder(h) { + const sched = chain.schedule // epoch schedule + const out = [] + const s = sched.shuffle[(h - 1) % config.leaders] + if (s) out.push(s.name) + for (let i = 1; i <= config.leaders; i++) { + const b = chain.recentBlocks[chain.recentBlocks.length - i] + if (!b) break + if (out.indexOf(b.miner) === -1) out.push(b.miner) + } + if (config.standbyEnabled) // Layer H tail + for (const st of sched.standbys || []) + if (out.indexOf(st.name) === -1) out.push(st.name) + return out +} + +function dueAt(h, p) { + return chain.getLatestBlock().timestamp + (p + 1) * config.blockTime + + (p > 0 ? config.skipGraceMs : 0) +} + +// ---------- quorum (one helper, used by tryNextStep and _getQuorumThreshold) ---------- +function isAbsent(name, head) { // pure chain data, no timer + const t = lastScheduledTurn(name, head) // max h ≤ head with S(h) = name + if (t === null) return false // never scheduled yet in this epoch + return chain.blockAt(t).miner !== name +} + +function quorumThreshold(head) { + const set = chain.schedule.set || [] // epoch set + const E = set.filter(n => !isAbsent(n, head)).length + const q = Math.min(4, Math.max(config.quorumMin, E)) + return { q: consensus.isActive() ? q : Math.min(q + 1, set.length), E } +} + +// ---------- producer ---------- +function tryMine(h) { + const l = ladder(h), p = l.indexOf(NODE_OWNER) + if (p < 0) return + setTimeout(() => chain.mineBlock(), Math.max(0, dueAt(h, p) - Date.now())) +} + +// ---------- validator (after the existing field/continuity checks) ---------- +function validateSkips(block, p) { + if (!config.skipRecording) return true + if (!Array.isArray(block.skips)) return !config.skipStrict // warn mode tolerates + const expected = ladder(block._id).slice(0, p) + const ok = block.skips.length === expected.length + && block.skips.every((n, i) => n === expected[i]) + && new Set(block.skips).size === block.skips.length + && block.skips.indexOf(block.miner) === -1 + if (!ok && config.skipStrict) return false + if (!ok) logr.warn('skips mismatch at #' + block._id, block.skips, expected) + return true +} +``` + +## Appendix B — parameter reference + +| Parameter | Value | Unit | Consensus? | Activation | +|---|---|---|---|---| +| `L` (`leaders`) | 5 | leaders | yes (schedule) | unchanged | +| `blockTime` | 3000 | ms | yes | unchanged | +| `consensusRounds` | 2 | rounds | yes | unchanged | +| `maxDrift` | 200 | ms | local policy | unchanged | +| `skipRecording` | true | bool | yes (additive field) | `H_S` | +| `skipStrict` | false→true | bool | yes (new rejection) | `H_strict` | +| `skipGraceMs` | 500 | ms | producer only | `H_S` | +| `N` (`jailMissThreshold`) | 30 | turns | yes (derived state) | `H_S` | +| `quorumEligibility` | `lastTurn` | mode | local policy | `H_S` | +| `haltBreaker` | true | bool | local policy | `H_S` (env `HALT_BREAKER=0` to disable) | +| `haltBreakerMs` | 21 000 | ms | local policy | `H_S` | +| `J` (`jailBlocks`) | 200 | blocks | yes | `H_S` | +| `leaderStandbys` | 5 | accounts | yes | `H_standby` | +| `quorumMin` | 3 | votes | local policy | `H_S` | +| `pendingBlockMaxMs` | 30 000 | ms | local policy | `H_S` | +| `heartbeatTxType` | 18 | tx type | no (existing tx) | `H_S` | + +## Appendix C — code references (baseline `e15c1f0`) + +* `src/chain.js`: `Block` 22, `prepareBlock` 68, `mineBlock` 127, `minerWorker` 228, + schedule regeneration 294, validation 499-598, early check 585, `minerSchedule` 691, + `generateLeaders` 723, `calculateHashForBlock` 812, `rebuildState` 906. +* `src/consensus.js`: `activeLeaders` 47, threshold 74, `tryNextStep` 69, `round` 170, + `endRound` 274, `scheduleForceFinalize` 387, `_forceFinalize` 420, + `_resolveForceFinalize` 489, `_applyForceFinalize` 600, `verifySignature` 644. +* `src/config.js`: `blockTime` 26, `leaders` 66, `maxDrift` 90, `forceFinalize` 180, + `forceFinalizeFallback` 185, `history` 188-203, `read` 205. +* `src/p2p.js`: `MessageType` 46, `NEW_BLOCK` 348, `BLOCK_CONF_ROUND` 392, `recover` 469. +* `src/leaderStats.js`: `processBlock` 17, `getWriteOps` 74. +* `src/transactions/transfer.js`: `amount` strictly positive 12 (`canBeZero = false`). +* `src/transactions/enableNode.js`: idempotent `pub_leader` `$set` + `cache.addLeader`. +* `src/blocks.js`: append-only BSON + 8-byte index (schema-less). +* `src/main.js`: schedule bootstrap on restart 88-99, `startDaemon` 136-144. diff --git a/doc/economics_fork_13330000.md b/doc/economics_fork_13330000.md new file mode 100644 index 0000000..ff2412d --- /dev/null +++ b/doc/economics_fork_13330000.md @@ -0,0 +1,186 @@ +# Economics hard fork #13330000 - supply-anchored pool, vote rate cap, pow determinism + +Single hard fork gated at block `13330000`; every change only activates from that height. +Branch: `new_econs` - commit `46c77ff` (base: `feat/auto-force-finalize`). +Diff: 6 files, +432 / -10. + +## What this fork does (summary) + +1. Sizes the 8h reward pool as a percentage of total supply instead of a frozen constant. +2. Caps the DTC payout of a single vote, proportional to network activity over a reference + window, so one account can no longer drain an idle network's whole pool. +3. Replaces `Math.pow` with exact integer arithmetic (`pow10`/`ipow`) so the reward math is + bit-for-bit identical on every node/engine. +4. Adds a consensus supply accumulator (`eco.totalSupplyUnits`) that these two pool changes + rely on, plus persistence and self-healing. + +## 1. Reward pool as % of supply + +- **`src/config.js:205-208`** - new `13330000` entry in `config.history`: + + ```js + initialSupplyBlock: 13320066, // anchor block (frozen, measured) + initialSupply: 572311976.600145, // total supply (DTC) at that block + rewardPoolYearlyRate: 0.10, // 10%/year -> ~52,265 DTC/window vs fixed 150001 + vtReferenceTotal: 15500000 // reference activity for the rate cap + ``` + +- **`src/economics.js:87-97`** - in `rewardPool()`: if `rewardPoolYearlyRate` is a number, + `theoricalPool = round(supply_units/1000 x rate / 1095)` instead of the constant + `rewardPoolAmount`. `1095` = windows/year (`365x24x3600x1000 / (9600x3000)`). + +- **`src/economics.js:88-92`** - guard: if the `totalSupplyUnits` accumulator is not + bootstrapped yet -> `logr.fatal` + `process.exit(1)` (never a silent fork with a wrong pool). + +### Motivation + +The constant `rewardPoolAmount = 150001`/window is a paper ceiling of ~28.7%/year that was +never adjusted while the network grew from ~400M to ~572M supply; real emission ran at only +~1.7%/year because activity, not the constant, bounded it. An arbitrary, stale constant is +both invisible (wrong mental model of emission) and unmaintainable (it needs manual tuning +every time supply moves). Making the pool a % of total supply: + +- fees the pool to the economic size of the network, so emission is self-adjusting; +- aligns the policy number with something meaningful (10%/year target) instead of a magic + per-window figure; +- keeps the leader stipend (9,600/window) at ~18% of a normal pool instead of an ever- + shrinking share. + +## 2. Single-vote rate cap + +- **`src/economics.js:334-341`** - in `print()`: after the `floor` and before the + `rewardPoolMaxShare` backstop: + + ```js + thNewCoins = Math.min(thNewCoins, eco.floor(stats.theo * |vt| / vtReferenceTotal)) + ``` + + Effect: one vote pays at most `pool * vt / vtReferenceTotal`. Example: 5,000 VT on a + network with ~zero activity -> ~16.9 DTC (previously up to ~15,000). + +### Motivation + +Pre-fork a whale voting on a dead network still walked away with up to 10% of the whole +8h window (the `rewardPoolMaxShare` backstop only scales with `avail`, i.e. with the same +pool the whale is emptying). That is a value-extraction bug, not a curation feature: a +single account with a large accumulated `vt` could monetize inactivity. The cap makes the +payout proportional to `vt` *normalized* by a reference level of real activity +(15,500,000 VT ~= historical p90 per 8h window), so a whale earns at most what it would +earn on a reasonably busy network. Below that reference, rewards scale down linearly; above +it the old pool-splitting math still applies. This also fixes the pre-fork quirk where the +"no votes yet" branch pays a fixed 1 DTC minimum: post-fork the first vote prints dust +(~0.003 DTC), i.e. nothing worth gaming. + +### No cap on account VT (deliberate) + +No limit was placed on the VT (voting power) an account can hold or accrue. VT is a +time-based stake: `GrowInt` grows it continuously at `balance / vtGrowth` +(`vtGrowth = 360000000` = +1 VT/h per DTC on average; `transaction.js:257,364`, +`chain.js:771`). That mechanism is left fully untouched because: + +- capping VT would change pre-existing consensus behavior on every past block (a second, + unrelated fork), and would open a new class of side effects (splitting, timing games); +- the abuse was in the *payout*, not the VP economy. Acting on the output (`print()`) + caps the damage exactly where it was exploitable while leaving curation incentives and + the time-weighted stake model intact. + +## 3. Numeric determinism (`pow10`/`ipow`) + +- **`src/economics.js:391-401`** - two new helpers on `eco`: + - `pow10(p)` -> exact integer `10^p` (bit-identical to `Math.pow(10,p)` for `p<=22`, but engine-independent) + - `ipow(base, exp)` -> repeated multiplication for integer exponents +- **9 sites `Math.pow(10,*)` -> `eco.pow10(*)`** (pre-fork neutral, same bits): + `round`/`floor` (`:405`,`:409`), `precisionMulti` (`:241`), `tipAmt` x2 (`:253`), `rentability` x2 (`:386`). +- **`src/economics.js:153-157`** - `accountPrice`: `Math.pow(5/len, 4)` is **not** bit-identical + to `ipow` -> the swap is **fork-gated** (pre-fork `Math.pow`, post-fork `ipow`). + +### Motivation + +All of these functions run inside block/transaction validation and their results are part of +the chain's consensus history. `Math.pow` is libm code: correct but not guaranteed to return +the same last ULPs on every engine, architecture or optimizer. A node that computes a reward +one ULP differently would finalize a different `dist`/`burn` and split the network. For +integer powers of ten (`n <= 22`) the result is exactly representable, so a plain +multiplication loop returns the identical bits everywhere - deterministic with zero semantic +change. `accountPrice` is the one place with a fractional base (`5/len`), where `Math.pow` +is genuinely non-reproducible; there the loop is enabled only from the fork height to avoid +changing pre-fork account prices. + +## 4. Supply accounting (new consensus state) + +- **`src/economics.js:22`** - new `eco.totalSupplyUnits` field (integer, 1e-3 units) = total + supply accumulated from `initialSupplyBlock`. + +- **`src/chain.js:304-320`** - at the top of `chain.output()` (which runs *after* the `config` + refresh, so it is always at `block._id`): + - lazy bootstrap at the anchor: `eco.totalSupplyUnits = round(initialSupply x 1000)` (cold-rebuild case) + - otherwise `+= round(dist x 1000) - round(burn x 1000)` for every block `> initialSupplyBlock` + - `logr.fatal` if not bootstrapped at a block != anchor + +- **`src/chain.js:913-940`** - `chain.scanSupply(from,to,cb)`: sums `dist - burn` over an + inclusive range; synchronous file-store path (`blocks.readRange`), Mongo fallback + (`_id: {$gte,$lte}`). + +### Motivation + +The pool sizing needs a supply value that every node derives **identically from block data**, +because it changes what is distributed. The `/supply` endpoint is a Mongo aggregation over +account balances - a denormalized view, not consensus state. The accumulator is instead built +from `block.dist`/`block.burn`, which are consensus-validated per block, so supply becomes a +deterministic function of the chain. `initialSupply` is a one-time measured snapshot frozen at +the fork config; the exponential `dist - burn` from the anchor onward is exact integer math. +The bootstrap allows fresh nodes (which replay from block 0) to reach the same value without +trusting anything: they re-derive it from the same blocks. + +## 5. Persistence and restart + +- **`src/cache.js:296`** - `cache.writeToDisk` saves `totalSupplyUnits` in `state` next to + `headBlock` (on every block). + +- **`src/main.js:88-90`, `109-110`** - restore from `state` in both paths (daemon and rebuild + resume) only if `state.headBlock` matches the head (self-healing on crash). + +- **`src/main.js:122-135`** - `bootstrapSupply(targetBlock, cb)`: if the value is missing from + state or behind the head, recompute via `chain.scanSupply(anchor+1 ... targetBlock)`; + skipped if pre-fork or already valid. + +- **`src/main.js:137-146`** - `startRebuild` wrapped by `bootstrapSupply(startBlock-1, ...)`; + the old body is now `rebuildFrom()`. + +### Motivation + +Without persistence every restart (and every resume of an interrupted rebuild) would re-scan +up to ~millions of blocks before a single transaction could run. Storing the accumulator next +to `headBlock` makes restart O(1) and crash-consistent: the value is written at the same time +as the head, and the restore is accepted only when the two match. Any mismatch (crash between +block append and state write, stale state) falls back to a scan, so the accumulator can never +be served stale - correctness wins over speed, and the guard in `rewardPool()` turns any +still-missing value into a loud fatal instead of a silent wrong distribution. + +## 6. Governance locked out of the anchor + +- **`src/config.js:241-245`** - `allowedKeys` filters out `initialSupply`/`initialSupplyBlock` + -> **only a new fork can correct them**, never `cache.state[1]`. + +### Motivation + +The anchor keys define the consensus supply from which every reward is derived. If governance +(an `effectiveBlock` override) could rewrite them mid-chain, a node that applied the override +would start accumulating from a different base than nodes that never received it, and the two +chains would quietly produce different pools and split. These are not tunable parameters - +they are invariants, exactly like a key of `history`, and must therefore change only through +the same single, atomic mechanism that created them: a new fork entry. + +## 7. Tests + +- **`test/supply-anchor.js`** (new, 25 checks): pre/post-fork gating, pre-fork stays identical + (`theo` = 150001, uncapped ~750 DTC whale, `votes === 0 -> 1`), pool proportional to supply, + fatal when the accumulator is missing, rate cap (16.86 DTC post vs 750 pre, first vote -> + dust), `pow10` == `Math.pow` bit-identical, gated `accountPrice`, source-guards on + `chain`/`cache`/`main`, protected scope (`decayInt.js`, `validate/float.js`, + `tippedVote.js` untouched). + +## Pre-fork invariance + +The 4 new keys don't exist below `13330000`; the `pow10` swaps are bit-identical; +`votes === 0 -> 1` and `rewardPoolMaxShare` are intact. Lint: 0 errors; all 3 test suites pass. \ No newline at end of file diff --git a/doc/mainnet-deployment-and-rollback.md b/doc/mainnet-deployment-and-rollback.md new file mode 100644 index 0000000..27fe574 --- /dev/null +++ b/doc/mainnet-deployment-and-rollback.md @@ -0,0 +1,649 @@ +# Avalon Mainnet Deployment & Rollback Plan (Code Upgrade without enabling Economy Fork #13330000) + +**Target Release:** `v2.0.3` (branch `feat/auto-force-finalize`, tag `v2.0.3`) +**Migration Type:** Code upgrade from `new_net` to the refactored codebase without activating Hard Fork #13330000 +**Economy:** Existing economy remains fully intact (no changes to DTC balances, fees, rewards, or economic parameters) +**Safety Level:** CRITICAL - Production Mainnet +**Last Updated:** 2026-10-21 + +> ⚠️ **NEVER touch MongoDB directly during migration.** The chain state lives in MongoDB. Always use `mongodump`/`mongorestore` or filesystem snapshots of the Mongo volume. +> ⚠️ **Tags are never moved.** Any superseding release gets a new tag. +> ⚠️ **All nodes must run the same commit.** Version mismatch will cause network splits. + +--- + +## Table of Contents + +1. [Pre-Flight Checklist](#pre-flight-checklist) +2. [Backup Strategy (CRITICAL)](#backup-strategy-critical) +3. [P2P Catchup Fix (v2.0.3-hotfix)](#p2p-catchup-fix-v203-hotfix) +4. [Deployment Procedure](#deployment-procedure) +5. [Post-Deployment Verification](#post-deployment-verification) +6. [Rollback Procedure (Full Rollback)](#rollback-procedure-full-rollback) +7. [Emergency Procedures](#emergency-procedures) +8. [Appendix](#appendix) + +--- + +## 1. Pre-Flight Checklist + +### 1.1 Environment Requirements +- [ ] Node.js >= 24 (verified by `node --version`) +- [ ] Docker & Docker Compose installed +- [ ] MongoDB running and accessible +- [ ] Sufficient disk space for backups (at least 2x current DB size) +- [ ] All operators notified and available on cutover channel +- [ ] Maintenance window scheduled + +### 1.2 Code Preparation +- [ ] Merge PR #2 (`feat/auto-force-finalize`) to target branch +- [ ] Tag released as `v2.0.3` +- [ ] Apply P2P catchup fixes if not already included (see section 3) +- [ ] Build Docker images for all node types +- [ ] Verify no `Hard Fork #13330000` references in logs/config +- [ ] Run static verification (see runbook S2) + +### 1.3 Network State +- [ ] Record current block height: `curl -s localhost:3001/count` +- [ ] Check all leaders are online and syncing +- [ ] Verify no ongoing forks or consensus issues +- [ ] Document peer list for all nodes + +--- + +## 2. Backup Strategy (CRITICAL) + +**You MUST create these backups BEFORE making any changes.** Store them in a secure location with multiple copies. + +### 2.1 MongoDB Full Backup (Primary Rollback Path) + +This is the **most important backup**. The chain lives in MongoDB, not `blocks.bson`. + +```bash +# Set backup directory with timestamp +BACKUP_DIR="/backup/avalon/$(date +%Y%m%d_%H%M%S)" +mkdir -p $BACKUP_DIR + +# Full MongoDB dump (all databases) +mongodump --host : --out $BACKUP_DIR/mongodump + +# Or if using Docker +docker exec mongodump --archive --gzip > $BACKUP_DIR/mongo-full.archive.gz + +# Verify backup +ls -lh $BACKUP_DIR/ +mongorestore --dryRun --archive --gzip < $BACKUP_DIR/mongo-full.archive.gz 2>&1 | tail -5 +``` + +### 2.2 Git Repository Backup + +```bash +# In Avalon repo directory +cd /path/to/avalon +git fetch --all --tags +git log -1 --oneline > $BACKUP_DIR/git-commit.txt +git branch -a > $BACKUP_DIR/git-branches.txt +git describe --tags > $BACKUP_DIR/git-describe.txt + +# Create a tarball of the repo state +tar czf $BACKUP_DIR/avalon-repo.tar.gz -C $(dirname $(pwd)) $(basename $(pwd)) +``` + +### 2.3 Configuration Backup + +```bash +# Backup all configs +cp config.js $BACKUP_DIR/config.js.backup 2>/dev/null +cp .env $BACKUP_DIR/.env.backup 2>/dev/null +cp -r docker/ $BACKUP_DIR/docker/ 2>/dev/null +cp -r scripts/ $BACKUP_DIR/scripts/ 2>/dev/null +``` + +### 2.4 Node State Snapshot (Optional but Recommended) + +```bash +# For each node, snapshot state +for port in 3001 3002 3003; do + curl -s localhost:$port/count > $BACKUP_DIR/count_port$port.txt + curl -s localhost:$port/peers > $BACKUP_DIR/peers_port$port.txt + curl -s localhost:$port/version > $BACKUP_DIR/version_port$port.txt +done +``` + +### 2.5 Backup Verification + +```bash +# Verify Mongo dump is valid +gzip -t $BACKUP_DIR/mongo-full.archive.gz && echo "GZIP OK" + +# Record backup location +echo "BACKUP_LOC=$BACKUP_DIR" >> /root/avalon-cutover-vars.sh +echo "BACKUP_HASH=$(sha256sum $BACKUP_DIR/mongo-full.archive.gz | awk '{print $1}')" >> /root/avalon-cutover-vars.sh +``` + +**CRITICAL:** Store `$BACKUP_DIR` location and hash securely. You'll need them for rollback. + +--- + +## 3. P2P Catchup Fix (v2.0.3-hotfix) + +As discovered in S4 dry-run, the new anti-DoS rate limiter can prevent stuck nodes from auto-recovering. Apply these fixes before deployment. + +### 3.1 Apply Fixes to Source + +Edit `src/p2p.js` with the following changes: + +#### Fix A: Reset recovery state on disconnect when all peers lost +```javascript +closeConnection: (ws) => { + const idx = p2p.sockets.indexOf(ws) + if (idx !== -1) + p2p.sockets.splice(idx, 1) + logr.debug('a peer disconnected, '+p2p.sockets.length+' peers left') + // If we were catching up and lost peers, reset recovery state so + // p2p.refresh() can retry automatically instead of getting stuck. + if (p2p.recovering) { + if (p2p.sockets.length === 0) { + logr.debug('Lost all peers while recovering, resetting recovery state') + p2p.recovering = false + p2p.recoveringBlocks = [] + p2p.recoveredBlocks = {} + } + } +}, +``` + +#### Fix B: Pace recovery requests to avoid rate limiting +```javascript +recover: () => { + if (!p2p.sockets || p2p.sockets.length === 0) return + if (p2p._recoverTicking) return + if (Object.keys(p2p.recoveredBlocks || {}).length + (p2p.recoveringBlocks || []).length > max_blocks_buffer) return + if (!p2p.recovering) p2p.recovering = chain.getLatestBlock()._id + + let peersAhead = [] + for (let i = 0; i < p2p.sockets.length; i++) + if (p2p.sockets[i].node_status + && p2p.sockets[i].node_status.head_block > chain.getLatestBlock()._id + && p2p.sockets[i].node_status.origin_block === config.originHash) + peersAhead.push(p2p.sockets[i]) + + if (peersAhead.length === 0) { + p2p.recovering = false + return + } + + secureShuffle(peersAhead) + let champions = peersAhead.slice(0, Math.min(3, peersAhead.length)) + let champion = champions[0] + if (p2p.recovering+1 <= champion.node_status.head_block) { + p2p._recoverTicking = true + const next = p2p.recovering + 1 + p2p.recovering = next + // Space requests to avoid tripping the per-socket rate limit + champions.forEach((ch, idx) => { + setTimeout(() => { + try { p2p.sendJSON(ch, {t: MessageType.QUERY_BLOCK, d: next}) } catch(e){} + }, idx * 25) + }) + if (!p2p.recoveringBlocks) p2p.recoveringBlocks = [] + if (!p2p.recoveredBlocks) p2p.recoveredBlocks = {} + p2p.recoveringBlocks.push(next) + logr.debug('query block #'+next+' -- head block: '+champion.node_status.head_block) + setTimeout(() => { + p2p._recoverTicking = false + p2p.recover() + }, 80) + } +}, +``` + +#### Fix C: More permissive rate limits during recovery +```javascript +ws.isRateLimited = (t) => { + if (t !== MessageType.QUERY_BLOCK && t !== MessageType.NEW_BLOCK + && t !== MessageType.BLOCK_CONF_ROUND && t !== MessageType.FORCE_FINALIZE) + return false + const now = Date.now() + if (now - ws.msgWindow >= msg_rate_window) { + ws.msgWindow = now + ws.msgCount = 0 + } + ws.msgCount++ + // During active catch-up, be more permissive + let limit = msg_rate_max + if (p2p.recovering && (t === MessageType.NEW_BLOCK)) { + limit = 150 + } else if (p2p.recovering && t === MessageType.QUERY_BLOCK) { + limit = 120 + } else if (p2p.recovering && t === MessageType.BLOCK) { + limit = 150 + } + if (ws.msgCount > limit) { + logr.warn('P2P message rate limit exceeded, disconnecting peer') + return true + } + return false +} +``` + +### 3.2 Test Fixes Locally First +```bash +# Test on local testnet before applying to mainnet +cd /tmp/opencode/avalon-s4 +# Apply patches (done above) +docker restart avalon-testnet-bootstrap avalon-testnet-miner1 avalon-testnet-miner2 avalon-testnet-miner3 +# Verify no rate limit kicks during normal operation +docker logs --tail 20 avalon-testnet-bootstrap | grep -c "rate limit exceeded" +``` + +--- + +## 4. Deployment Procedure + +**Follow this exact order. Coordination is critical.** + +### 4.1 Pre-Cutover (T-60 minutes) + +```bash +# 1. Announce maintenance window +echo "[$(date)] Starting Avalon mainnet cutover preparation" | tee -a /var/log/avalon-cutover.log + +# 2. Create all backups (Section 2) +source /root/avalon-cutover-vars.sh # Will be created by backup script + +# 3. Verify all nodes are healthy +for node in leader1 leader2 leader3 leader4; do + ssh $node "curl -s localhost:3001/count && echo && curl -s localhost:3001/version" +done + +# 4. Sync all nodes to same height +# Wait until all nodes report same count +``` + +### 4.2 Freeze (T-10 minutes) - CRITICAL + +```bash +# STOP ALL LEADERS - coordinated in chat/voice +# NO NODE may remain on old code + +for node in leader1 leader2 leader3 leader4; do + ssh $node "systemctl stop avalon || pm2 stop avalon || docker stop avalon-node" & +done +wait + +echo "[$(date)] All nodes stopped" | tee -a /var/log/avalon-cutover.log +``` + +### 4.3 Verify Halt State + +```bash +# Check all nodes are stopped +for node in leader1 leader2 leader3 leader4; do + ssh $node "ps aux | grep -E '[a]valon|[n]ode.*main' || echo 'STOPPED'" +done + +# Verify MongoDB is still running +systemctl status mongod || docker ps | grep mongo +``` + +### 4.4 Deploy New Code + +```bash +# On each node +for node in leader1 leader2 leader3 leader4; do + ssh $node "cd /path/to/avalon && git fetch --all --tags && git checkout v2.0.3 && git log -1 --oneline && npm install && docker build -t avalon:\$(git rev-parse --short HEAD) . || true && docker-compose build || true" +done +``` + +### 4.5 Start New Version (T-0) + +```bash +# Start ALL nodes with NEW code simultaneously +# Ensure same commit on all nodes + +COMMIT=$(git rev-parse --short HEAD) +echo "[$(date)] Starting all nodes with commit $COMMIT" | tee -a /var/log/avalon-cutover.log + +for node in leader1 leader2 leader3 leader4; do + ssh $node "cd /path/to/avalon && export HTTP_HOST=0.0.0.0 && export CORS_ORIGIN='*' && export TRUST_PROXY=1 && export LOG_LEVEL=cons && nohup ./scripts/start.sh > /var/log/avalon.log 2>&1 & echo Started" & +done +wait + +echo "[$(date)] All nodes started" | tee -a /var/log/avalon-cutover.log +``` + +### 4.6 Monitor Startup (T+0 to T+10 minutes) + +```bash +# Watch logs for startup +for node in leader1 leader2 leader3 leader4; do + ssh $node "tail -f /var/log/avalon.log" & +done + +# Check for errors +sleep 60 +grep -iE "error|fatal|exception" /var/log/avalon.log | tail -20 +grep -c "Hard Fork #13330000" /var/log/avalon.log +``` + +--- + +## 5. Post-Deployment Verification + +### 5.1 Critical Checks (Must Pass) + +```bash +# 1. Version check - ALL nodes must report identical version +echo "=== VERSION CHECK ===" +for port in 3001 3002 3003 3004; do + echo -n "Port $port: " + curl -s localhost:$port/version + echo +done +# Expected: {"version":"2.0.3"} on ALL nodes + +# 2. Chain is advancing +echo "=== ADVANCEMENT CHECK ===" +for i in 1 2 3; do + sleep 30 + for port in 3001 3002 3003 3004; do + echo -n "Port $port: " + curl -s localhost:$port/count + echo + done + echo "---" +done +# Head must increase monotonically + +# 3. No economy fork +echo "=== FORK CHECK ===" +grep -c "Hard Fork #13330000" /var/log/avalon.log +# Expected: 0 + +grep "Hard Fork #" /var/log/avalon.log | tail -5 +# Only 241600 (and future scheduled forks) expected + +# 4. Chain continuity +HEAD=$(curl -s localhost:3001/count | tr -d '"') +PREV=$(curl -s localhost:3001/block/$((HEAD-1)) | grep -o '"hash":"[^"]*"' | head -1) +CURR_PHASH=$(curl -s localhost:3001/block/$HEAD | grep -o '"phash":"[^"]*"' | head -1) +echo "Continuity: $PREV vs $CURR_PHASH" +# Must match + +# 5. Supply sanity +curl -s localhost:3001/supply | head -c 100 +echo +# Should respond normally (not economy-related) +``` + +### 5.2 Network Health + +```bash +# Peer count +for port in 3001 3002 3003 3004; do + echo -n "Port $port peers: " + curl -s localhost:$port/peers | jq '. | length' +done +# Should have healthy peer connections + +# Check for rate limit errors +grep -c "P2P message rate limit exceeded" /var/log/avalon.log +# Should be 0 or very low + +# Check for recovery issues +grep "stuck\|recovery" /var/log/avalon.log | tail -10 +``` + +### 5.3 Consensus Health + +```bash +# Check for growing possBlocks (stuck consensus) +# This would indicate issues +grep "possBlocks" /var/log/avalon.log | tail -5 + +# Check force-finalize events (should be rare) +grep -c "Force finalizing" /var/log/avalon.log +grep -c "Block collision detected" /var/log/avalon.log +``` + +--- + +## 6. Rollback Procedure (Full Rollback) + +**If anything goes wrong, follow this procedure to restore previous state.** + +### 6.1 Decision to Rollback +Trigger rollback if: +- [ ] Nodes fail to start or crash repeatedly +- [ ] Chain stops advancing +- [ ] Fork detected (`Hard Fork #13330000` appears) +- [ ] Version mismatch across nodes +- [ ] Consensus stuck for >5 minutes +- [ ] Critical errors in logs + +### 6.2 Immediate Actions (T+0 Rollback) + +```bash +echo "[$(date)] INITIATING ROLLBACK" | tee -a /var/log/avalon-rollback.log + +# 1. Stop all nodes immediately +for node in leader1 leader2 leader3 leader4; do + ssh $node "systemctl stop avalon || pm2 stop avalon || docker stop avalon-node" & +done +wait +echo "[$(date)] All nodes stopped for rollback" | tee -a /var/log/avalon-rollback.log +``` + +### 6.3 Restore MongoDB from Backup + +**This will completely restore chain state to pre-migration point.** + +```bash +source /root/avalon-cutover-vars.sh + +# Stop MongoDB +systemctl stop mongod || docker stop $MONGO_CONTAINER + +# Backup current (failed) state just in case +mv /var/lib/mongodb /var/lib/mongodb.failed.$(date +%s) + +# Restore from backup +if [ -f "$BACKUP_LOC/mongo-full.archive.gz" ]; then + mongod --fork --logpath /var/log/mongod-restore.log + mongorestore --archive --gzip --drop < $BACKUP_LOC/mongo-full.archive.gz + echo "[$(date)] MongoDB restored" | tee -a /var/log/avalon-rollback.log +else + # Try mongodump format + mongorestore --drop --dir $BACKUP_LOC/mongodump +fi + +# Restart MongoDB +systemctl restart mongod || docker start $MONGO_CONTAINER +sleep 10 +``` + +### 6.4 Restore Code to Previous Version + +```bash +for node in leader1 leader2 leader3 leader4; do + ssh $node "cd /path/to/avalon && git fetch --all --tags && git checkout " +done +echo "[$(date)] Code restored to previous version" | tee -a /var/log/avalon-rollback.log +``` + +### 6.5 Restore Configurations + +```bash +for node in leader1 leader2 leader3 leader4; do + ssh $node "BACKUP_LOC=$BACKUP_LOC && cd /path/to/avalon && cp \$BACKUP_LOC/config.js.backup ./config.js 2>/dev/null && cp \$BACKUP_LOC/.env.backup ./.env 2>/dev/null" +done +``` + +### 6.6 Start Nodes with Restored Version + +```bash +for node in leader1 leader2 leader3 leader4; do + ssh $node "cd /path/to/avalon && export HTTP_HOST=0.0.0.0 && nohup ./scripts/start.sh > /var/log/avalon.log 2>&1 &" & +done +wait +echo "[$(date)] Nodes restarted with restored version" | tee -a /var/log/avalon-rollback.log +``` + +### 6.7 Verify Rollback Success + +```bash +sleep 60 + +# Check versions match old version +for port in 3001 3002 3003 3004; do + curl -s localhost:$port/version +done + +# Check chain height matches backup +BACKUP_HEIGHT=$(cat $BACKUP_LOC/count_port3001.txt) +CURRENT_HEIGHT=$(curl -s localhost:3001/count) +echo "Backup height: $BACKUP_HEIGHT, Current: $CURRENT_HEIGHT" + +# Verify chain is advancing again +sleep 60 +curl -s localhost:3001/count + +# Check for errors +grep -i "error\|fatal" /var/log/avalon.log | tail -10 +``` + +### 6.8 Post-Rollback + +- [ ] Announce rollback complete in channel +- [ ] Document reason for rollback in incident report +- [ ] Preserve failed state backups for analysis +- [ ] Do NOT delete rollback backups until root cause identified +- [ ] Schedule post-mortem + +--- + +## 7. Emergency Procedures + +### 7.1 Node Stuck in Recovery (P2P Rate Limit Issue) + +If a node is stuck and not catching up: + +```bash +# Try manual recovery endpoint +curl -s -H 'Accept: application/json' http://localhost:3001/recover +# Rate limited to 3/min per IP + +# Check logs +tail -50 /var/log/avalon.log | grep -E "rate limit|recover|disconnect" + +# If still stuck, restart node +systemctl restart avalon +``` + +**With the P2P fixes applied (section 3), this should happen automatically.** + +### 7.2 MongoDB Corruption + +```bash +# Stop node +systemctl stop avalon + +# Check MongoDB integrity +mongod --dbpath /var/lib/mongodb --repair + +# Or restore from backup if repair fails +# Follow rollback procedure section 6.3 +``` + +### 7.3 Fork Detected + +```bash +# IMMEDIATE FREEZE +systemctl stop avalon + +# Check logs for fork info +grep -B5 -A30 "fork" /var/log/avalon.log | tail -50 + +# Do NOT restart until consensus with other operators +# May need to rollback or coordinate +``` + +--- + +## 8. Appendix + +### 8.1 Useful Commands + +```bash +# Check node status +curl -s localhost:3001/count +curl -s localhost:3001/version +curl -s localhost:3001/peers +curl -s localhost:3001/schedule + +# Check logs +journalctl -u avalon -n 50 +tail -f /var/log/avalon.log + +# MongoDB checks +mongosh --eval "db.adminCommand({listDatabases:1})" +mongosh avalon --eval "db.blocks.countDocuments()" +mongosh avalon --eval "db.state.find({}).toArray()" + +# Process management +ps aux | grep avalon +systemctl status avalon +pm2 status +docker ps +``` + +### 8.2 Contact Information + +- **Lead Operator:** [Insert contact] +- **Backup Operator:** [Insert contact] +- **MongoDB Admin:** [Insert contact] +- **Emergency Channel:** [Insert channel] + +### 8.3 Checklist Template + +Copy this for each cutover: + +```markdown +## Cutover Checklist - [DATE] + +### Pre-Flight +- [ ] Backups created and verified +- [ ] All operators notified +- [ ] P2P fixes applied +- [ ] Tests passed on staging + +### Cutover +- [ ] All nodes stopped (T-10) +- [ ] New code deployed (T-5) +- [ ] All nodes started (T-0) +- [ ] Monitoring active + +### Verification +- [ ] All versions match +- [ ] Chain advancing +- [ ] No economy fork +- [ ] Peers connected +- [ ] No errors + +### Sign-off +- [ ] Operator 1: _____ +- [ ] Operator 2: _____ +- [ ] Operator 3: _____ +``` + +### 8.4 References + +- [Migration Runbook (EN)](./migration-runbook-no-econs.en.md) _(upgrade without enabling Economy Fork #13330000)_ +- [S4 Dry-Run Report](../../../../tmp/opencode/s4/S4-REPORT.md) +- [PR #2](https://github.com/dtube/avalon/pull/2) +- [Release v2.0.3](https://github.com/dtube/avalon/releases/tag/v2.0.3) + +--- + +**Remember:** When in doubt, **rollback**. It's always safer to rollback than to guess. The backups you create are your only path to recovery. \ No newline at end of file diff --git a/doc/migration-runbook-no-econs.en.md b/doc/migration-runbook-no-econs.en.md new file mode 100644 index 0000000..b613952 --- /dev/null +++ b/doc/migration-runbook-no-econs.en.md @@ -0,0 +1,449 @@ +# Migrating from `new_net` to the new code — without enabling the Economy Fork #13330000 + +> **Note:** This is a *code upgrade*, not an economy change. We are deploying the refactored Avalon codebase but **not enabling** the economy rules of Hard Fork #13330000. All existing DTC balances, fees, rewards, and economic parameters remain unchanged. + +**Type**: operational runbook +**Date**: 18 October 2026 +**Last verified**: 20 October 2026 — every check below was re-run on the tree of tag **`v2.0.2`** (= `v2.0.0` plus the gitar-bot review fixes and the Node 24 alignment, S1), and the network state was re-measured (head unchanged) +**From**: branch `new_net` (the code line the current network runs on, today halted) +**To**: the new code = tag **`v2.0.3`** on `feat/auto-force-finalize` (= the `new_econs` code line minus the economy fork `46c77ff`, plus the release-line-only fixes landed after the fork-day verification: `src/http/auth/index.js`, `src/http/index.js`, `src/p2p.js`, `test/audit-fixes.js`, `test/image-sharp.js`) +**Companion**: `doc/economics_fork_13330000.md` (what the new economy does, in detail) + +> **Revision 2026-10-28** — the force-finalization flag day was moved from `13,925,000` (~21 days) down to **`13,325,000`** (~4 h after the resume), exploiting the halted chain, and the admin endpoints (`/mineBlock`, `/debug`, `/recover`, `/logs`) became **fail-closed** when no token is configured. Both ship in tag **`v2.0.3`** (over `v2.0.2`), which is the certified tag used throughout this document; **`v2.0.2` predates the flag-day change and must not be used for S1**. Block `13330000` stays untouched. + +Checks performed for this runbook (in a throwaway worktree; re-run on 20 October 2026 on the `v2.0.2` tree, whose `src`/`test`/`scripts` match `new_econs` `6cc3b46` apart from the econs revert): + +- reverting the econs commit **applies with no conflicts** (5 modified files + `D test/supply-anchor.js`; 6 files, +10 / −432); +- **zero residue** of econs symbols in `src/`, `test/`, `scripts/` on the reverted tree (the `doc/` folder is not scanned on purpose: the companion and migration documents legitimately discuss these tokens — see the corrected grep in S2); +- `node test/audit-fixes.js` → **24 passed, 0 failed** (also after the revert); `node test/force-finalize.js` → **All tests passed**; +- `npx eslint ./src/*` → identical to the baseline (**1 pre-existing error**: `src/http/auth/index.js:86`, `curly`; 244 warnings); +- the resulting history is `{0, 241600, 13325000}`: **the force-finalization fork stays intact** (config one-liner in S2 returns `FF@13325000: true | sigVer: 2`, and the reverted `src/` contains no `13330000` entry). + +--- + +## 0. TL;DR + +| In the migration | Out | +|---|---| +| 168 commits (181 at the code tip `6cc3b46`: everything above `cefabdd` is non-consensus — docs, javalon2 bump, `/version` endpoint, releases 2.0.0–2.0.2): security hardening (SSRF, NoSQLi, prototype pollution, log redaction), **anti-fork force-finalization**, halt-recovery, rate limiting, Node ≥ 24, Docker testnet, log viewer, dependency bumps (`javalon2` now `^1.1.10`) | **only** commit `46c77ff` `feat(econs): add hard fork #13330000 (supply-anchored pool, vote rate cap)` — 6 files, +432 / −10 | + +Three things to keep in mind: + +1. **One single dangerous moment**: the *flag day*. All leaders must run the same code **on the same day**, because the new code also changes several validators (R2). +2. **Five new defaults that break clients** if left unconfigured: `CORS_ORIGIN`, `HTTP_HOST`, the global rate limit, `TRUST_PROXY`, 1 MB body limit (S3). +3. **The network is halted**: resuming the chain *is* the cutover, and until block 13,325,000 (~4 h after the resume) there is no force-finalization as a safety net (S5, R15). + +--- + +## 1. What "the new economy" is — and what it is not + +### 1.1 The object to exclude + +A **single commit**, `46c77ff`, among the last code commits on the branch (the commits above it touch code only in `cefabdd` — which does not touch the economy — and in the v2.0.1 review fixes `d0ca532`, which restore historical semantics; everything else above is non-consensus: docs, javalon2 bump, `/version` endpoint, releases 2.0.0–2.0.2): + +``` +46c77ff feat(econs): add hard fork #13330000 (supply-anchored pool, vote rate cap) + src/cache.js 2 lines touched + src/chain.js 43 + src/config.js 22 + src/economics.js 54 + src/main.js 34 + test/supply-anchor.js 287 (new) + ------------------------------------------------ + 6 files, +432 / -10 +``` + +What it adds, in short (details in `doc/economics_fork_13330000.md`): + +| Element | Effect from block 13,330,000 | +|---|---| +| `rewardPoolYearlyRate: 0.10` | pool 8 h = 10 %/year of total supply (~52,265 DTC) instead of the constant `rewardPoolAmount = 150001` | +| `vtReferenceTotal: 15500000` | cap on the payout of **a single vote** = `pool × \|vt\| / vtReferenceTotal` | +| `eco.totalSupplyUnits` + `chain.scanSupply()` + persistence in `cache.state` | supply accumulator (consensus state) used to compute the pool | +| `pow10` / `ipow` gated on `accountPrice` | numeric determinism (pre-fork the `Math.pow(10,n)` were already bit-identical) | +| `initialSupplyBlock: 13320066`, `initialSupply: 572311976.600145` | frozen anchor, filtered out by `allowedKeys` (governance cannot rewrite it) | + +### 1.2 What is NOT the new economy (and must be kept) + +Everything else on the branch, including another hard fork **that stays**: + +``` + 0 base config (effective values unchanged; only the internal rename blockHashSerialization → consensusSigVersion, value 1) + 241600 txLimits (already active on new_net) + 13325000 forceFinalize: true + consensusSigVersion: 2 <-- KEPT (height moved down from 13925000 while halted) +``` + +`13325000` is the *next* flag day — now set just above the resume head (13,320,067) instead of the original ~21-day horizon, because the halted chain makes the cutover a single coordinated restart. It enables force-finalization and moves consensus message serialization to the ordered-keys version. **It must be kept even in the "no economy" migration**: it is the safety net against forks, i.e. the main reason for migrating at all. + +Note: `new_net` has **no force-finalization code at all** (`consensus.js` 290 → 684 lines, 47 commits on halt/consensus/quorum, `scripts/auto_resolve_halt.sh` new, 794 lines). That, not the economy, is the substance of the migration. + +### 1.3 How the exclusion was built (audit trail) + +**Operators do not build anything**: the exclusion is already certified as tag `v2.0.3` — `git checkout v2.0.3` (S1) *is* the whole step. The three variants below are the decision record of how that tree was produced (and why V3 was rejected): + +| Variant | How | Diff | Pros | Cons | +|---|---|---|---|---| +| **V1 — revert** (tree-equivalent) | `git revert 46c77ff` on the new code | 6 files (+10 / −432) + 1 revert commit | verified, trivial, removes dead code *and* the test | a `revert` commit in history (noise if the branch is public) | +| **V2 — linear history** | branch from `46c77ff^` + `cherry-pick` every commit above it | tree **identical** to V1 | no `revert` in the log: preferable if the branch is published for node operators | requires a cherry-pick sequence (no conflict expected) | +| **V3 — config entry only** | drop the `13330000` block from `config.history` | ~10 lines | minimal change; re-enabling the economy = putting one entry back | leaves dead code + an unused accumulator and **makes `test/supply-anchor.js` fail** (it must be deleted); a future merge from `new_econs` can reintroduce the entry with a silent conflict | + +In every variant the golden rule holds: **the new economy is excluded in code only, never at runtime** (no env var disables it; no `allowedKeys` turns it off). + +--- + +## 2. Network state at the time of writing (measured) + +| Datum | Value | Source | +|---|---|---| +| Head | **13,320,067** (re-measured 2026-10-20: unchanged) | `GET https://dtube.fso.ovh/count` | +| Last block | ts `2026-06-27T01:01:05Z`, miner `brianphobos`, `phash` consistent with block 13320066 | `GET /block/13320067` | +| Halted for | **~115 days** as of 2026-10-20 (the tip is not corrupted: it is a halt, not a fork at the tip) | timestamp comparison | +| Econs fork 13,330,000 | **not activated yet**: **9,933 blocks** missing ≈ **8.3 h** at 3 s block time | height difference | +| Force-finalization fork 13,325,000 | **4,933 blocks** missing ≈ **4.1 h** at 3 s — moved down while the chain is halted | height difference | +| Economy anchor | 13,320,066 = **tip − 1** | `src/config.js` | + +Operational consequences: + +- **This is the right moment**: while the chain is halted, excluding the econs fork is neutral (no block produced under the new rules, nothing to reconcile). +- **But it is also urgent**: whoever restarts with the code that *contains* the entry activates it after ~8 h of production. If some nodes restart with the economy and others without, it splits (R1). +- **The anchor is pinned at the current tip − 1**: the new economy was prepared for a restart *from here*. One more reason not to move those two keys if it is to be activated later (R9). + +--- + +## 3. Preliminary decisions (to be closed before touching any node) + +- **D1 — Exclusion variant**: V1 / V2 / V3 (§1.3). Proposed default: **V1**, or **V2** if the branch is to be published. +- **D2 — Who upgrades, and when**: *all* active leaders, *all* nodes serving the public API listed in `AvalonAPINodes`, the indexers. Anyone staying on `new_net` **must** be shut down before the cutover block (R1/R2). +- **D3 — Will the new economy be re-enabled in the future?** If yes: it needs a **new fork entry** with a future height and a re-measured anchor. The `initialSupply`/`initialSupplyBlock` keys are consensus invariants: they do not move, they are not hand-edited (appendix C). +- **D4 — Point of no return and rollback**: define *beforehand* the block beyond which there is no going back (S9) and who has the authority to declare it. + +--- + +## 4. Migration steps + +### S0 — Pre-flight (before touching anything) 🔴 + +```bash +# 1. Snapshot of the current state: commit, config, keys +cd /path/avalon && git rev-parse HEAD && git status --short +cp -a .env /backup/env.$(date +%F) # if it exists +cp -a scripts/start.sh /backup/start.sh.$(date +%F) # it contains the node keys! + +# 2. Data backup (do BOTH if you are unsure which storage is in use) +cp -a "$BLOCKS_DIR"/blocks.bson /backup/blocks.bson.$(date +%F) +cp -a "$BLOCKS_DIR"/*.idx /backup/ 2>/dev/null +mongodump --db "${DB_NAME:-avalon}" --out /backup/mongo-$(date +%F) # if Mongo is used + +# 3. Versions and environment +node -v # must be >= 24 (new code: engines ">=24.0.0") +npm -v +nginx -v 2>/dev/null; grep -rn "proxy_set_header\|proxy_pass" /etc/nginx/ # reverse proxy? +``` + +To record on the cutover sheet: head height, head block hash, **commit** currently in production, ports (`HTTP_PORT`, `P2P_PORT`), peer list, expected tolerance in minutes. + +### S1 — Get the no-economy branch 🔴 + +**Recommended: use the release tag.** The verified no-econs tree is published as tag **`v2.0.3`** on branch `feat/auto-force-finalize` (verified 2026-10-20: identical to `new_econs` in every file except the 6 econs files; the tree has since gained the release-line-only fixes listed above): + +```bash +cd /path/avalon +git fetch --all --tags +git checkout v2.0.3 # new code without econs, with /version + review fixes +``` + +**What the releases add over `v2.0.0`** — each re-verified on the real tree: + +**`v2.0.1`** — three fixes from the automated code review (gitar-bot, PR #2, 20 October 2026): + +1. `scripts/auto_resolve_halt.sh`: the `blocks.index` offset is decoded as `(high << 8) + low`, matching the encoding written by `src/blocks.js` (`high = pos >> 8`, `low = pos & 0xFF`). The previous `<< 32` made every real truncation position explode past the file size, so the last-resort BSON truncation could never succeed on a live chain; +2. `src/http/account/index.js`: `validate.string` now receives `allowedUsernameCharsOnlyMiddle`, so accounts whose names contain `-` or `.` in the middle (legitimate per tx validation) are no longer 404-ed; +3. `src/consensus.js`: the finalization quorum is `floor(n·2/3) + 1` — the smallest integer strictly above 2/3 — restoring the historical `new_net` semantics that `ceil` + `>=` had weakened for `activeLeaders` counts that are multiples of 3. + +**`v2.0.2`** (same day, over `v2.0.1`): Docker images and the startup guard aligned to **Node 24** — `docker/Dockerfile` (NodeSource `setup_24.x`), `docker/testnet/Dockerfile` (`FROM node:24`), `docker/test.dockerfile` (`node:24-alpine`) and the `main.js` version check (`>= v24`, was `>= v18` while `engines` required ≥24): closes R8. + +**`v2.0.3`** (28 October 2026, over `v2.0.2`): the force-finalization flag day moved from `13,925,000` down to **`13,325,000`**, and the admin endpoints (`/mineBlock`, `/debug`, `/recover`, `/logs`) became **fail-closed** when no token is configured (`ADMIN_ALLOW_ANONYMOUS=1` opts back in). It also carries the S4 testnet scaffolding and the `sharp` bump + `package-lock.json` (S8/R14). + +`v2.0.0` stays valid for provenance; every operator path in this document uses `v2.0.3`. + +Building the branch yourself — **not required for the migration** (audit trail, kept for the record: the tag already *is* this tree): + +Variant **V1** (verified clean): + +```bash +cd /path/avalon +git fetch --all +git log --oneline -5 new_econs # orientation: docs, deps, /version and the release commits above cefabdd +git checkout -b new_net_noecons new_econs +git revert --no-commit 46c77ff # no conflicts, no manual intervention +git status --short # expected: 5 M + D test/supply-anchor.js +git diff --stat # expected: 6 files, 10 insertions(+), 432 deletions(-) +git commit -m "revert(econs): exclude fork #13330000 from this release" +``` + +Variant **V2** (same tree, linear history): + +```bash +git checkout -b new_net_noecons 46c77ff^ # = 9774aca +git cherry-pick 46c77ff..new_econs # every commit above the econs one: + # docs, deps, /version, releases and the + # release commits (no conflict expected) +``` + +Equivalence check (any variant — also confirms the tag): + +```bash +# expected: the 6 economy files (+10/−432) plus the 5 release-line-only files +# (src/http/auth/index.js, src/http/index.js, src/p2p.js, test/audit-fixes.js, +# test/image-sharp.js) — scoped to code on purpose: doc/ revisions may legitimately differ +git diff new_econs v2.0.3 --stat -- src test scripts # or your new_net_noecons branch +``` + +### S2 — Static, offline verification ⚠️ + +```bash +export PATH="...node24/bin:$PATH" # Node >= 24 +npm ci # or npm install if the lockfile is out of sync + +# 1. No residue of the economy +grep -rn "rewardPoolYearlyRate\|vtReferenceTotal\|initialSupplyBlock\|totalSupplyUnits\|13330000" \ + src test scripts 2>/dev/null +# expected: no output. doc/ is deliberately NOT scanned: economics_fork_13330000.md +# and the migration documents discuss these tokens on purpose (the previous version +# of this command scanned doc/ and its exclusion did not match this document's filename). + +# 2. The config at the fork height no longer activates anything, and the rest stays +node -e 'global.logr=new Proxy({},{get:()=>()=>{}});global.cache={state:{}}; +const c=require("./src/config.js"); +const p=c.read(13330000), f=c.read(13325000); +console.log("econs:",p.rewardPoolYearlyRate,p.vtReferenceTotal,p.initialSupplyBlock, + "| pool:",p.rewardPoolAmount,"| FF@13325000:",f.forceFinalize,"| sigVer:",f.consensusSigVersion)' +# expected: econs: undefined undefined undefined | pool: 150001 | FF@13325000: true | sigVer: 2 + +# 3. Quality gates +npm run lint # expected: 2 pre-existing `curly` errors (auth/index.js:90, p2p.js:533) + ~251 warnings +node test/audit-fixes.js # expected: 24 passed, 0 failed +node test/force-finalize.js # expected: All tests passed +# test/supply-anchor.js: it must NOT exist (the revert deletes it; in V3 delete it by hand) + +# 4. Confirm you are on the certified release tag +git describe --tags # expected: v2.0.3 +``` + +### S3 — Config, environment, proxy 🔴 + +The new code adds **18 environment variables** (re-counted 2026-10-20: the tree goes from 45 to 63 `process.env` references) and **removes none**. Five of them change the *default* behavior compared to `new_net` and can break clients if ignored: + +| Variable | New default | `new_net` | Why it matters | +|---|---|---|---| +| `CORS_ORIGIN` | **`false`** → no CORS headers | `cors()` = `*` | 🔴 **the web client (dtube2) can no longer read cross-origin API responses**. Must be set (e.g. `*`, or the client origin) | +| `HTTP_HOST` | **`127.0.0.1`** | `0.0.0.0` | 🔴 API unreachable from outside / from the container unless set explicitly (`docker-compose.yml` already passes it) | +| global rate limit | **50 req/s per IP** (new) | absent | heavy traffic (feeds, indexers, scripts) gets `429`; `/transact` has a separate limiter at **5 req/s** | +| `TRUST_PROXY` | unset → `X-Forwarded-For` **ignored** | header trusted | 🔴 behind nginx *all* clients share one bucket → mass `429`s, and admin sessions appear bound to the proxy IP. With a wrong value, spoofing reopens | +| body parser | **1 MB** | unlimited | large payloads → `413` | + +Of the 18 new variables, only ~10 affect the daemon runtime (4 of them are the security/auth must-configs: `ADMIN_TOKEN`, `LOG_ADMIN_TOKEN`, `TRUST_PROXY`, `CORS_ORIGIN`; 4 are abuse limits: `CONTENT_MAX_COMMENTS`, `CONTENT_MAX_RESULTS`, `IMG_MAX_BYTES`, `IMG_MAX_PIXELS`; 2 are the in-node log viewer: `LOG_FULL`, `LOG_PAGE`), 6 are parameters of the halt-recovery script only (`BSON_PATH`, `IDX_PATH`, `REMOVE_COUNT`, `NEW_HEIGHT`, `DRY_RUN`, `TMP_COLL`), 1 is runtime ops (`SKIP_EARLY_CHECK_BLOCKS`) and 1 is testnet-only (`BOOTSTRAP_HOST`). + +🔴 **Discoverability gap to close before the cutover**: **none** of the new variables is declared in `scripts/start.sh` (it declares only 12 exports), even though the README points there for "the list of available environment variables". Append a commented-out block to `scripts/start.sh` (or ship an `.env.example`) listing the 18 new variables with their defaults, so operators can actually find them. + +Other new variables, to be evaluated: `IMG_MAX_BYTES` (10 MB), `IMG_MAX_PIXELS` (20 MPixels), `CONTENT_MAX_COMMENTS` (2000), `CONTENT_MAX_RESULTS` (10000), `LOG_ADMIN_TOKEN` / `LOG_FULL` / `LOG_PAGE` (in-node log viewer), and the variables used only by the halt scripts (`BSON_PATH`, `IDX_PATH`, `REMOVE_COUNT`, `NEW_HEIGHT`, `DRY_RUN`, `SKIP_EARLY_CHECK_BLOCKS`, `TMP_COLL`, `BOOTSTRAP_HOST`). + +Authentication: in the new code `requireAuth()` protects `/debug`, `/recover`, `/logs`, `/mineBlock`. Since `v2.0.3` these **fail closed**: with no token configured they return `401`, so an unconfigured node no longer serves them anonymously. Set `ADMIN_TOKEN`/`LOG_ADMIN_TOKEN` before exposing the node; only deliberate local use should set `ADMIN_ALLOW_ANONYMOUS=1` (the local `docker/testnet` does exactly that). + +Behind a reverse proxy: + +```nginx +proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; +proxy_set_header X-Forwarded-Proto $scheme; +# then in the node's .env: +TRUST_PROXY=1 # "1" = trust the first hop; 0/false = do not trust (default) +CORS_ORIGIN='*' # or the exact origin of the web client +HTTP_HOST=0.0.0.0 +``` + +Docker: `docker/docker-compose.yml` lost `version:` and now passes `HTTP_HOST=0.0.0.0`. Node is aligned to **24** everywhere since `v2.0.2`: mainnet image (`docker/Dockerfile`, NodeSource `setup_24.x`), testnet image (`docker/testnet/Dockerfile`, `FROM node:24`), `docker/test.dockerfile` (`node:24-alpine`) and the `main.js` startup guard (`>= v24`) — all consistent with `engines: node >= 24` (R8 closed). + +### S4 — Dry run on a local testnet ⚠️ + +Before touching mainnet, reproduce the migration on `docker/testnet` (3 miners + bootstrap, ports 3101-3104 / 6101-6104): + +1. checkout the release tag and build (`git checkout v2.0.3 && docker compose build`); +2. chain from scratch: verify that blocks are produced and that `Hard Fork #13330000` **never appears** in the logs; +3. **determinism test**: full rebuild from genesis on the new-code-without-economy and compare around a hundred block hashes with a `new_net` node → they must match (validators changed, R2); +4. force-finalization test (two near-simultaneous `/mineBlock` on different miners); +5. test of a control node syncing from scratch (replay + accumulator not involved). + +### S5 — Flag day: mainnet cutover 🔴 + +Non-negotiable order: **first everything stops, then truncate/resume, then restart with one single code version**. + +```bash +# 1. Freeze: stop ALL leaders (coordinated, chat/voice open) +# - no node may stay on new_net +# 2. Halt diagnosis (always dry-run first) +DRY_RUN=1 ./scripts/auto_resolve_halt.sh +# The script truncates blocks (BSON or Mongo) and rewrites the state. +# Guardrails to know: MAX_REMOVE_BLOCKS (10), MAX_TOTAL_REMOVE (30) and +# .avalon_halt/state.json → if the chain has not advanced since the last truncation +# the script REFUSES to truncate again ("Manual intervention required"). +# 3. Start the new version on all nodes (same commit!) +cd /path/avalon +export HTTP_HOST=0.0.0.0 CORS_ORIGIN='*' TRUST_PROXY=1 ADMIN_TOKEN=... LOG_ADMIN_TOKEN=... +nohup ./scripts/start.sh > /var/log/avalon.log 2>&1 & # or systemd / pm2 / screen +``` + +### S6 — Post-cutover verification (checklist) + +```bash +curl -s localhost:3001/count # head ADVANCING (13,320,068+) +curl -s localhost:3001/block/13320068 | head -c 200 # phash = hash of 13320067 +curl -s localhost:3001/supply | head -c 200 # sanity (endpoint unchanged, not econs) +curl -s localhost:3001/version # expected: {"version":"2.0.3"} — IDENTICAL on every node +grep -c "Hard Fork #13330000" /var/log/avalon.log # expected: 0 (forever) +grep "Hard Fork #" /var/log/avalon.log | tail -3 # only 241600 expected (and 13325000 from the future fork) +``` + +Plus, on the control node: rebuild from genesis → same head **and same hash** as the other nodes. Payout/vote format: unchanged (pool = 150001). First full day of observation: `/count` monotonic, no growing `possBlocks`, stable peers. Every operator runs `curl -s localhost:3001/version` and posts the result in the cutover chat: all nodes must answer `2.0.3`. + +### S7 — Clients, indexers, embed + +- **No client change is needed to exclude the economy**: the fork touches no HTTP endpoint (`46c77ff` does not modify `src/http/**`) and `/supply` stays as it was. +- **But**: `CORS_ORIGIN` must be set on *all* public nodes, otherwise dtube2 (browser) cannot read responses. +- `client/settings.js` → `AvalonAPINodes` (`api.avalonblocks.com`, `dtube.fso.ovh`, `avalon.luminade.fun`, `dtube.tekraze.com`, `testnet.dtube.fso.ovh`, plus a local dev entry `localhost:3001`): every one of these nodes must be upgraded and configured, otherwise the client keeps talking to old instances. +- Rate limit: `/transact` 5 req/s per IP and 50 req/s globally → check flows that send many transactions in a burst (batches of votes/uploads from dtube2) and add client-side retry/backoff. +- `javalon2`: the node moves from `^1.1.7` to `^1.1.10` (bumped 2026-10-20, commit `04ad87b`; 1.1.10 adds a DMCA-endpoint fallback fix and compatible dependency bumps), but **does not use it for consensus validation** (it uses `secp256k1` directly: no chain impact; it is only required by `scripts/mega_generic_test.js`). The bump changes `signVerify` on the JS side (hash reconstruction + rejection of missing `pubKey`/`signature`/`hash`): check third-party scripts/tools that signed with the old formulation. +- `dtube-embed`, `ipfs-caching`, `DTubeGo` are not involved in this migration. + +### S8 — Watch and second flag day (13,325,000) + +- By **13,325,000** (4,933 blocks ≈ **4 h** at 3 s from the current head — deliberately just above the resume block, exploiting the halt) **all nodes must run the new code**: that fork enables `forceFinalize` and moves `consensusSigVersion` to 2 (ordered-keys serialization). A node left behind does not produce/validate the same signatures → fork or halt. +- Until that block the network has force-finalization **disabled**: a new halt can only be resolved with `auto_resolve_halt.sh`. +- To monitor: `Hard Fork #13325000` in the logs at the right time, peer health, any multiple `possBlocks`. +- **Post-migration backlog** (dependency audit 2026-10-20): `apidoc` `^1.2.0` → `^0.29.0` (dev-only) stays a later, off-delta commit. The `sharp` `^0.32.6` → `^0.35.5` bump (high: libvips/libheif CVEs on the user-image processing endpoint) is **no longer deferred** — it now ships **inside the flag-day delta** (required on Node ≥ 24 and for the CVEs) and is pinned by the committed `package-lock.json`. Every node must run `npm ci` from the lockfile and pass `node test/image-sharp.js` (upload+resize); treat it as an R14 change. + +### S9 — Rollback + +- **Immediate rollback** (before producing blocks with the new code): stop → `git checkout` the previous commit → restart. Cost: the minutes of downtime. +- 🔴 **After the new code has validated blocks**: going back to `new_net` means **truncating to the cutover block**, because `new_net` does not know about the validation fixes introduced by the new code (R2/R3). It requires the S0 backup and the same `auto_resolve_halt.sh`. +- Save so you can go back: `blocks.bson`/Mongo dump, previous commit, `.env`, `.avalon_halt/state.json`, logs for the period. + +--- + +## 5. Risks + +| # | Risk | Impact | Prob. | Mitigation | +|---|---|---|---|---| +| **R1** | Exclusion applied to only some nodes → at block 13,330,000 some apply the fork and others do not: different `dist`/pool, **split chain** | 🔴 critical | medium | flag day with all leaders; S2 verification (one-liner on every node) + `grep "Hard Fork #13330000"` = 0 + `curl /version` = 2.0.3 on every node; no `new_net` node online | +| **R2** | The new code changes **validators** (`validate/json.js`, `float.js`, `integer.js`, `string.js`, bandwidth check on create-account, block size bounds, JSON with `.`/`$` keys rejected): a block/tx accepted by the old code may be rejected by the new one | 🔴 fork or impossible rebuild | high if the cutover is not coordinated | S4 testnet with a control rebuild and hash comparison; simultaneous cutover; no mixed nodes | +| **R3** | Rollback after post-cutover blocks: the old version cannot validate the new chain | 🔴 data loss | medium | define the point of no return in D4; S0 backup; targeted truncation S9 | +| **R4** | `CORS_ORIGIN` not set (default `false`) → the web client cannot read the APIs | 🔴 broken client | high | set it on all public nodes (S3, S7) | +| **R5** | `HTTP_HOST` default `127.0.0.1` → API unreachable from outside | 🔴 service down | medium | set `HTTP_HOST=0.0.0.0` (S3) and verify from outside, not just from localhost | +| **R6** | Global rate limit 50 r/s + `TRUST_PROXY` unset behind a proxy: one bucket for everybody → mass `429`s; admin sessions bound to the proxy IP | 🟠 degradation/abuse | high | correct `TRUST_PROXY` + nginx headers; consider limits in nginx; monitor `429`s | +| **R7** | Rate limit on `/transact` (5 r/s) breaks dtube2 batch flows | 🟠 lost tx | medium | client backoff/retry; check vote/upload flows | +| **R8** | Node: `engines >= 24` but Docker images on **Node 18** (`docker/Dockerfile`, `docker/testnet/Dockerfile`) and runtime check `>= 18` — found during validation | 🟠 unsupported install/runtime | low *(closed)* | **closed in `v2.0.2`**: images aligned (`setup_24.x`, `FROM node:24`, `node:24-alpine`) and `main.js` guard raised to `>= v24`; validate with `npm ci` on Node ≥ 24 | +| **R9** | Re-enabling the economy later by touching `initialSupplyBlock`/`initialSupply` (frozen anchor, filtered by `allowedKeys`) | 🔴 silent fork | low | new fork entry with a future height and a measured anchor; never move existing keys (appendix C) | +| **R10** | `eco.totalSupplyUnits` not bootstrapped → `logr.fatal` + `process.exit(1)` at the first block of the fork (for a node crossing the anchor without restarting) | 🟠 node dies | low (excluded in this migration) | this is why the anchor sits at the current tip: restart all nodes as part of the resume | +| **R11** | Unresolved halt: force-finalization is **not active** until 13,325,000; the script guardrails (max 10 blocks per pass, 30 total, `.avalon_halt` state) may refuse the truncation | 🔴 chain halted | medium | `DRY_RUN=1` first, plan the manual intervention, S0 backup, agreed maintenance window | +| **R12** | Without the new economy these stay open: 28.7 %/year emission ceiling with a constant pool of `150001`, and **pool drainage by a single whale** on an inactive network (value-extraction bug, `economics_fork_13330000.md` §2) | 🟠 economic | certain | explicit, dated business decision (D3): re-enable with a later fork | +| **R13** | `scripts/start.sh` contains a **plaintext private key** (`NODE_OWNER_PRIV=34Ep…`) on both branches, and history holds "remove private keys" commits that were later undone | 🔴 security | certain | rotate the node key before circulating this document or the branch; do not version the real `start.sh` | +| **R14** | Dependency bumps (`mongodb` 4.2→4.17, `secp256k1`, `express`, now `javalon2` ^1.1.10, and `sharp` ^0.35.5 which now ships **inside the flag-day delta**): different behavior/indexes on existing DBs | 🟠 runtime errors | medium | test on a copy of the DB; read the logs on first start; `npm ci` from the lockfile; for `sharp` run `node test/image-sharp.js` (upload+resize) on every node | +| **R15** | The new code *is* an anti-halt release (consensus.js 290→684 lines) but force-finalization is disabled until 13,325,000: the stability of the resume depends on new logic never yet exercised in production | 🟠 new halt | medium | force-finalization testnet (S4); `auto_resolve_halt.sh` ready; close observation (S8) | + +--- + +## 6. Definition of done + +- [ ] Tag checked out on every node (`git checkout v2.0.3`) and `git diff new_econs v2.0.3 --stat -- src test scripts` shows the 6 economy files **plus** the release-line-only fixes (`src/http/auth/index.js`, `src/http/index.js`, `src/p2p.js`, `test/audit-fixes.js`, `test/image-sharp.js`) +- [ ] Residue `grep` and the S2 config one-liner → expected outcome (no econs keys, `pool: 150001`, `FF@13325000: true`, `sigVer: 2`) +- [ ] `npm run lint` + `test/audit-fixes.js` + `test/force-finalize.js` green as per baseline +- [ ] Node ≥ 24 on all nodes and in the Docker images +- [ ] Every node on the certified tag (`git describe --tags` = `v2.0.3`); `curl /version` returns `2.0.3` on every node +- [ ] `CORS_ORIGIN`, `HTTP_HOST`, `TRUST_PROXY`, `ADMIN_TOKEN`/`LOG_ADMIN_TOKEN` set and verified **from outside the local network** +- [ ] New env vars declared in `scripts/start.sh` (commented block) so operators can discover them +- [ ] Testnet dry run: rebuild from genesis with matching hashes + force-finalization tested +- [ ] Backup of blocks, DB, `.env`, previous commit in a safe, verified place +- [ ] All leaders stopped, none on `new_net`, cutover chat open +- [ ] After the cutover: `/count` advances, chain hashes consistent on all nodes, **zero** `Hard Fork #13330000` in the logs +- [ ] Shared calendar with the network: everyone on the new code by block **13,325,000** +- [ ] Private key in `scripts/start.sh` rotated + +--- + +## 7. ⏱ Execution time estimates + +Hands-on time per step, estimated against the real node layout (mainnet: `blocks.bson` 4.2 GB + 102 MB index, Mongo ~2.7 GB): + +| Step | Hands-on | Basis | +|---|---|---| +| **S0 pre-flight** | **~15 min** | blocks.bson/index copy ≈ 1–2 min (4.3 GB local disk / 1 Gbit), `mongodump` 2.7 GB ≈ 2–3 min, git/env/key snapshots ~5 min | +| **S1 release checkout** | **~1 min** | `git checkout v2.0.3` (tag already certified; the self-build variants are audit-only) | +| **S2 static verification** | **~10–15 min** | `npm ci` 1–5 min (warm cache), greps + config one-liner + lint + 2 test suites | +| **S3 config/proxy** | **~30 min per node** | `.env` + new commented block in `start.sh` + nginx (`X-Forwarded-For`) + verification from outside | +| **S4 testnet dry run** | **~1–2 h first run**, ~45 min on repeat | `docker compose build` 15–30 min first time; chain from scratch, determinism rebuild, force-finalization test | +| **S5 flag day** | **~45–60 min window** | stop all leaders 10–15, `DRY_RUN=1` diagnosis 5–10, truncate/restart 10–15, first-block verification 10–15 | +| **S6 post-cutover** | **~15 min + 1–4 h unattended** | curl checklist; the genesis rebuild on the control node runs in background (13.3 M blocks) | +| **S7 clients/indexers** | **~1 h** | `CORS_ORIGIN` on every public node in `AvalonAPINodes` (~10–15 min each) + dtube2 batch-flow checks | +| **S8 watch** | **~15 min total** | until 13,325,000 (≈4 h after the resume), light monitoring | +| **S9 rollback plan** | **~30 min** | D4 decision + backups already covered by S0 | + +Totals: +- **One operator on their own node: ~4–6 h hands-on** (~1 h of which is the cutover window), plus 1–4 h of unattended rebuild and ~4 h of light observation. +- **Realistic calendar: 2 working days** — one for S0–S4 (testnet dry run), one for the flag day S5–S6 — plus the window coordinated with the other leaders. +- The critical manual work is concentrated in **S0–S3 + S5 (~2 h)**: the rest is waiting or monitoring. + +--- + +## Appendix A — What is in the new code (measured 2026-10-20) + +168 commits / 102 files / +5131 −801 measured at `cefabdd` (the old code tip); at code tip `6cc3b46`: 181 commits / 106 files / +5604 −812 — everything above `cefabdd` is non-consensus (docs, javalon2 bump, `/version` endpoint, releases 2.0.0–2.0.2; the extra files vs `cefabdd` are the refreshed `doc/v1.5.2-upgrade.md`, this runbook and `src/http/version/`). + +| Area | Examples | +|---|---| +| Consensus / anti-fork | force-finalization with quorum, backoff, verified signature, broadcast; `forceFinalizeFallback` (default `false`: the chain stops instead of risking a fork); `consensusSigVersion: 2` gated at 13,325,000 | +| Halt recovery | `scripts/auto_resolve_halt.sh` (794 lines), BSON/Mongo truncation, anti-loop guardrails | +| HTTP security | SSRF (`src/http/ssrf.js`, IP/TLS pinning), input validation, query caps, global and per-endpoint rate limits, shared `requireAuth`, IP-bound sessions, log/credential redaction | +| P2P network | websocket payload cap, dedicated rate limiter, TTL on `blockSenders`, O(1) cleanup | +| Cache/block robustness | atomic state writes, Mongo queue error handling, truncated BSON handled, `sanitizeQuery` | +| Validators | `float`/`integer`/`string`/`json` (NaN/Infinity, `.`/`$` keys, zero bounds), JSON size in bytes | +| Platform | Node ≥ 24, multi-node `docker/testnet`, in-node log viewer, `/version` endpoint, `javalon2` 1.1.10 | +| Economy (the only excluded part) | commit `46c77ff` | + +## Appendix B — Hard fork timeline + +| Height | Content | Status | +|---|---|---| +| 0 | base config (`rewardPoolAmount: 150001`, `rewardPoolMaxShare: 0.1`, …) | active | +| 241600 | `txLimits` | active | +| 13,320,067 | current head (chain halted since 2026-06-27; re-measured 2026-10-20: unchanged) | — | +| **13,330,000** | **economy: pool % supply + vote cap + accumulator** | **to be excluded (never activated: 9,933 blocks missing ≈ 8.3 h at 3 s)** | +| 13,325,000 | `forceFinalize: true`, `consensusSigVersion: 2` | activates ≈4 h after the resume (was ~21 days; moved down while the chain is halted) | + +## Appendix C — Economy invariants (if it is ever re-enabled) + +- `initialSupplyBlock: 13320066` / `initialSupply: 572311976.600145` are **frozen measurements** and are **filtered by `allowedKeys`**: governance cannot rewrite them, only a new fork entry can. +- Never move those keys between history entries: it would change `config.read(n)` for blocks already produced. +- `bootstrapSupply()` (upgrade/restart) rebuilds the accumulator with `chain.scanSupply(anchor+1 … head)` from BSON or Mongo: a node that restarts after the anchor repairs itself; a node that *crosses* the anchor **without** restarting ends in `logr.fatal` + `process.exit(1)`. +- Re-enabling the economy = a new fork with the desired future height (anchor 13,320,066 can stay; the cost is the scan). + +## Appendix D — Quick commands + +```bash +# Does my checkout really exclude the economy? (expected: exactly the 6 files) +git diff new_econs HEAD --stat -- src test scripts + +# Any residue? (src/test/scripts only — see S2 for why doc/ is excluded) +grep -rn "rewardPoolYearlyRate\|vtReferenceTotal\|initialSupplyBlock\|totalSupplyUnits" src test scripts + +# Config at the fork height + next fork intact +node -e 'global.logr=new Proxy({},{get:()=>()=>{}});global.cache={state:{}};const c=require("./src/config.js"); +const p=c.read(13330000),f=c.read(13325000);console.log(p.rewardPoolYearlyRate,p.vtReferenceTotal,p.initialSupplyBlock,p.rewardPoolAmount,f.forceFinalize,f.consensusSigVersion)' + +# Network state +curl -s https://dtube.fso.ovh/count + +# Same release on this node? (expected: 2.0.3) +curl -s localhost:3001/version + +# Has the node activated the economy? (must stay empty) +grep "Hard Fork #13330000" /var/log/avalon.log +``` diff --git a/doc/migration-runbook-no-econs.md b/doc/migration-runbook-no-econs.md new file mode 100644 index 0000000..211f3f2 --- /dev/null +++ b/doc/migration-runbook-no-econs.md @@ -0,0 +1,449 @@ +# Migrazione da `new_net` al nuovo codice — senza attivare l'Economy Fork #13330000 + +> **Nota:** questo è un *upgrade di codice*, non un cambio di economia. Si distribuisce la codebase Avalon rifattorizzata ma **non** si attivano le regole economiche dell'Hard Fork #13330000. Tutti i saldi DTC, le fee, le ricompense e i parametri economici restano invariati. + +**Tipo**: runbook operativo +**Data**: 18 ottobre 2026 +**Ultima verifica**: 20 ottobre 2026 — tutti i controlli sotto sono stati rieseguiti sull'albero del tag **`v2.0.2`** (= `v2.0.0` più i fix della review gitar-bot e l'allineamento a Node 24, S1), e lo stato della rete è stato rimisurato (head invariato) +**Partenza**: branch `new_net` (la linea di codice su cui gira la rete attuale, oggi ferma) +**Arrivo**: nuovo codice = tag **`v2.0.3`** su `feat/auto-force-finalize` (= la linea di codice di `new_econs` meno il commit `46c77ff`, più i fix della linea di release arrivati dopo la verifica del fork day: `src/http/auth/index.js`, `src/http/index.js`, `src/p2p.js`, `test/audit-fixes.js`, `test/image-sharp.js`) +**Companion**: `doc/economics_fork_13330000.md` (cosa fa la nuova economia, in dettaglio) + +> **Revisione 2026-10-28** — il flag day della force-finalization è stato spostato da `13.925.000` (~21 giorni) a **`13.325.000`** (~4 h dopo la ripresa), sfruttando la catena ferma, e gli endpoint admin (`/mineBlock`, `/debug`, `/recover`, `/logs`) sono diventati **fail-closed** senza token. Entrambe le cose sono nel tag **`v2.0.3`** (sopra `v2.0.2`), che è il tag certificato usato in questo documento; **`v2.0.2` è precedente al cambio di flag day e non va usato per S1**. Il blocco `13330000` resta intatto. + +Verifiche eseguite per questo runbook (in un worktree temporaneo; rieseguite il 20 ottobre 2026 sull'albero `v2.0.2`, il cui `src`/`test`/`scripts` corrisponde a `new_econs` `6cc3b46` fatta eccezione per il revert econs): + +- il revert del commit econs **applica senza conflitti** (5 file modificati + `D test/supply-anchor.js`; 6 file, +10 / −432); +- **zero residui** dei simboli econs in `src/`, `test/`, `scripts/` sull'albero revertato (la cartella `doc/` non viene scansionata apposta: companion e documenti di migrazione discutono quei simboli di proposito — vedi il grep corretto in S2); +- `node test/audit-fixes.js` → **24 passed, 0 failed** (anche dopo il revert); `node test/force-finalize.js` → **All tests passed**; +- `npx eslint ./src/*` → identico alla baseline (**2 errori preesistenti** `curly`: `src/http/auth/index.js:90`, `src/p2p.js:533`; ~251 warning); +- la history risultante è `{0, 241600, 13325000}`: **il fork di force-finalization resta intatto** (l'one-liner di S2 restituisce `FF@13325000: true | sigVer: 2`, e l'albero revertato `src/` non contiene la entry `13330000`). + +--- + +## 0. TL;DR + +| Dentro la migrazione | Fuori | +|---|---| +| 168 commit (181 alla punta di codice `6cc3b46`: sopra `cefabdd` solo non-consenso — docs, bump javalon2, endpoint `/version`, release 2.0.0–2.0.2): hardening sicurezza (SSRF, NoSQLi, prototype pollution, redazione log), **force-finalization anti-fork**, halt-recovery, rate limiting, Node ≥ 24, testnet Docker, log viewer, bump dipendenze (`javalon2` ora `^1.1.10`) | **solo** il commit `46c77ff` `feat(econs): add hard fork #13330000 (supply-anchored pool, vote rate cap)` — 6 file, +432 / −10 | + +Tre cose da tenere in testa: + +1. **Un solo momento pericoloso**: il *flag day*. Tutti i leader devono girare lo stesso codice **lo stesso giorno**, perché il nuovo codice cambia anche vari validatori (R2). +2. **Cinque default nuovi che rompono i client** se non configurati: `CORS_ORIGIN`, `HTTP_HOST`, rate limit globale, `TRUST_PROXY`, body 1 MB (S3). +3. **La rete è ferma**: la ripresa della catena *è* il cutover, e fino al blocco 13.325.000 (~4 h dopo la ripresa) non esiste force-finalization come rete di sicurezza (S5, R15). + +--- + +## 1. Cosa è "la nuova economia" — e cosa non lo è + +### 1.1 L'oggetto da escludere + +Un **unico commit**, `46c77ff`, tra gli ultimi commit di codice del branch (i commit sopra di esso toccano il codice solo in `cefabdd` — che non tocca l'economia — e nei fix della review v2.0.1 `d0ca532`, che ripristinano la semantica storica; tutto il resto sopra è non-consenso: docs, bump javalon2, endpoint `/version`, release 2.0.0–2.0.2): + +``` +46c77ff feat(econs): add hard fork #13330000 (supply-anchored pool, vote rate cap) + src/cache.js 2 righe toccate + src/chain.js 43 + src/config.js 22 + src/economics.js 54 + src/main.js 34 + test/supply-anchor.js 287 (nuovo) + ------------------------------------------------ + 6 file, +432 / -10 +``` + +Cosa aggiunge, in sintesi (dettaglio in `doc/economics_fork_13330000.md`): + +| Elemento | Effetto dal blocco 13.330.000 | +|---|---| +| `rewardPoolYearlyRate: 0.10` | pool 8 h = 10 %/anno del supply totale (~52.265 DTC) invece della costante `rewardPoolAmount = 150001` | +| `vtReferenceTotal: 15500000` | cap sul payout di **un singolo voto** = `pool × \|vt\| / vtReferenceTotal` | +| `eco.totalSupplyUnits` + `chain.scanSupply()` + persistenza in `cache.state` | accumulatore di supply (stato di consenso) su cui si calcola il pool | +| `pow10` / `ipow` gated su `accountPrice` | determinismo numerico (pre-fork i `Math.pow(10,n)` erano già bit-identici) | +| `initialSupplyBlock: 13320066`, `initialSupply: 572311976.600145` | anchor frozen, filtrato da `allowedKeys` (la governance non può riscriverlo) | + +### 1.2 Cosa NON è la nuova economia (e va tenuto) + +Tutto il resto del branch, incluso un altro hard fork **che resta**: + +``` + 0 config base (valori effettivi invariati; solo il rename interno blockHashSerialization → consensusSigVersion, valore 1) + 241600 txLimits (già attiva su new_net) + 13325000 forceFinalize: true + consensusSigVersion: 2 <-- RESTA (altezza abbassata da 13925000 a catena ferma) +``` + +`13325000` è il flag day *successivo* — ora fissato appena sopra l'head di ripresa (13.320.067) invece del vecchio orizzonte di ~21 giorni, perché la catena ferma rende il cutover un unico riavvio coordinato. Abilita la force-finalization e passa la serializzazione dei messaggi di consenso alla versione a chiavi ordinate. **Va tenuto anche nella migrazione "senza economia"**: è la rete di sicurezza contro i fork, cioè il motivo principale per cui si migra. + +Nota: `new_net` **non ha nessun codice di force-finalization** (`consensus.js` 290 → 684 righe, 47 commit su halt/consenso/quorum, `scripts/auto_resolve_halt.sh` nuovo da 794 righe). Questa, non l'economia, è la sostanza della migrazione. + +### 1.3 Come è stata costruita l'esclusione (traccia d'audit) + +**Gli operatori non costruiscono nulla**: l'esclusione è già certificata come tag `v2.0.3` — `git checkout v2.0.3` (S1) *è* tutto il passo. Le tre varianti sotto sono il registro decisionale di come è stato prodotto quell'albero (e perché V3 è stato scartato): + +| Variante | Come | Diff | Pro | Contro | +|---|---|---|---|---| +| **V1 — revert** (equivalente all'albero) | `git revert 46c77ff` sul nuovo codice | 6 file (+10 / −432) + 1 commit di revert | verificata, banale, rimuove codice morto *e* il test | un commit `revert` nella storia (rumore se il branch è pubblico) | +| **V2 — storia lineare** | branch da `46c77ff^` + `cherry-pick` di tutti i commit sopra | albero **identico** a V1 | nessun `revert` nel log: preferibile se il branch viene pubblicato per i node operator | richiede una sequenza di cherry-pick (nessun conflitto atteso) | +| **V3 — solo la entry di config** | togliere il blocco `13330000` da `config.history` | ~10 righe | modifica minima; riattivare l'economia = rimettere una entry | lascia codice morto + accumulatore inutilizzato e **fa fallire `test/supply-anchor.js`** (va cancellato); un merge futuro da `new_econs` può reintrodurre la entry con conflitto silenzioso | + +In ogni variante vale la regola d'oro: **la nuova economia si esclude solo nel codice, mai a runtime** (nessun env var la disabilita; nessuna `allowedKeys` la spegne). + +--- + +## 2. Stato della rete al momento della scrittura (misurato) + +| Dato | Valore | Fonte | +|---|---|---| +| Head | **13.320.067** (rimisurato 2026-10-20: invariato) | `GET https://dtube.fso.ovh/count` | +| Ultimo blocco | ts `2026-06-27T01:01:05Z`, miner `brianphobos`, `phash` coerente col blocco 13320066 | `GET /block/13320067` | +| Fermi da | **~115 giorni** al 2026-10-20 (il tip non è corrotto: è un halt, non un fork sul tip) | confronto timestamp | +| Fork econs 13.330.000 | **non ancora attivato**: mancano **9.933 blocchi** ≈ **8,3 h** di tempo-blocco (3 s) | differenza altezze | +| Fork force-finalization 13.325.000 | mancano **4.933 blocchi** ≈ **4,1 h** a 3 s — abbassata mentre la catena è ferma | differenza altezze | +| Anchor economia | 13.320.066 = **tip − 1** | `src/config.js` | + +Conseguenze operative: + +- **È il momento giusto**: finché la catena è ferma, escludere il fork econs è neutro (nessun blocco prodotto con le regole nuove, niente da riconciliare). +- **Ma è anche urgente**: chi riparte con il codice che *contiene* la entry lo attiva dopo ~8 h di produzione. Se alcuni nodi ripartono con l'economia e altri senza, si spacca (R1). +- **L'anchor è fissato al tip attuale − 1**: la nuova economia è stata preparata per una ripartenza *da qui*. Motivo in più per non spostare quelle due chiavi se in futuro la si vuole attivare (R9). + +--- + +## 3. Decisioni preliminari (da chiudere prima di toccare i nodi) + +- **D1 — Variante di esclusione**: V1 / V2 / V3 (§1.3). Default proposto: **V1**, o **V2** se il branch va pubblicato. +- **D2 — Chi aggiorna, e quando**: *tutti* i leader attivi, *tutti* i nodi che servono l'API pubblica di `AvalonAPINodes`, gli indexer. Chi resta su `new_net` **deve** essere spento prima del blocco di cutover (R1/R2). +- **D3 — La nuova economia si riattiva in futuro?** Se sì: serve una **nuova entry di fork** con altezza futura e anchor rimisurato. Le chiavi `initialSupply`/`initialSupplyBlock` sono invarianti di consenso: non si spostano, non si editano a mano (appendice C). +- **D4 — Punto di non ritorno e rollback**: definire *prima* il blocco oltre il quale non si torna indietro (S9) e chi ha l'autorità per dichiararlo. + +--- + +## 4. Passi della migrazione + +### S0 — Pre-flight (prima di toccare qualunque cosa) 🔴 + +```bash +# 1. Fotografia dello stato attuale: commit, config, chiavi +cd /percorso/avalon && git rev-parse HEAD && git status --short +cp -a .env /backup/env.$(date +%F) # se esiste +cp -a scripts/start.sh /backup/start.sh.$(date +%F) # contiene le chiavi del nodo! + +# 2. Backup dati (fai ENTRAMBI se non sei sicuro dello storage in uso) +cp -a "$BLOCKS_DIR"/blocks.bson /backup/blocks.bson.$(date +%F) +cp -a "$BLOCKS_DIR"/*.idx /backup/ 2>/dev/null +mongodump --db "${DB_NAME:-avalon}" --out /backup/mongo-$(date +%F) # se si usa Mongo + +# 3. Versioni e ambiente +node -v # deve essere >= 24 (nuovo codice: engines ">=24.0.0") +npm -v +nginx -v 2>/dev/null; grep -rn "proxy_set_header\|proxy_pass" /etc/nginx/ # reverse proxy? +``` + +Da annotare nel foglio di cutover: altezza head, hash del blocco head, **commit** attualmente in produzione, porte (`HTTP_PORT`, `P2P_PORT`), elenco peer, minuti di tolleranza previsti. + +### S1 — Ottenere il branch senza economia 🔴 + +**Consigliato: usare il tag di release.** L'albero verificato senza econs è pubblicato come tag **`v2.0.3`** sul branch `feat/auto-force-finalize` (verificato 2026-10-20: identico a `new_econs` in ogni file tranne i 6 file econs; l'albero ha poi guadagnato i fix della linea di release elencati sopra): + +```bash +cd /percorso/avalon +git fetch --all --tags +git checkout v2.0.3 # nuovo codice senza econs, con /version + fix della review +``` + +**Cosa aggiungono le release rispetto a `v2.0.0`** — ciascuno riverificato sull'albero reale: + +**`v2.0.1`** — tre fix dalla review automatica del codice (gitar-bot, PR #2, 20 ottobre 2026): + +1. `scripts/auto_resolve_halt.sh`: l'offset di `blocks.index` viene decodificato come `(high << 8) + low`, in accordo con la codifica scritta da `src/blocks.js` (`high = pos >> 8`, `low = pos & 0xFF`). Il precedente `<< 32` faceva esplodere ogni posizione di troncamento reale oltre la dimensione del file, quindi l'ultima risorsa di troncamento BSON non avrebbe mai potuto funzionare su una chain reale; +2. `src/http/account/index.js`: `validate.string` riceve ora `allowedUsernameCharsOnlyMiddle`, quindi gli account i cui nomi contengono `-` o `.` nel mezzo (legittimi per la validazione dei tx) non vengono più 404-ati; +3. `src/consensus.js`: la quorum di finalizzazione è `floor(n·2/3) + 1` — il più piccolo intero strettamente maggiore di 2/3 — ripristinando la semantica storica di `new_net` che `ceil` + `>=` aveva indebolito per conte di `activeLeaders` multipli di 3. + +**`v2.0.2`** (stesso giorno, sopra `v2.0.1`): immagini Docker e guard di avvio allineati a **Node 24** — `docker/Dockerfile` (NodeSource `setup_24.x`), `docker/testnet/Dockerfile` (`FROM node:24`), `docker/test.dockerfile` (`node:24-alpine`) e il check di versione in `main.js` (`>= v24`, era `>= v18` mentre `engines` richiedeva ≥24): chiude R8. + +**`v2.0.3`** (28 ottobre 2026, sopra `v2.0.2`): il flag day della force-finalization è passato da `13.925.000` a **`13.325.000`**, e gli endpoint admin (`/mineBlock`, `/debug`, `/recover`, `/logs`) sono diventati **fail-closed** senza token (`ADMIN_ALLOW_ANONYMOUS=1` riabilita l'accesso anonimo). Porta anche lo scaffolding testnet S4 e il bump di `sharp` + `package-lock.json` (S8/R14). + +`v2.0.0` resta valido per la provenienza; ogni percorso operativo di questo documento usa `v2.0.3`. + +Costruire il branch a mano — **non richiesto per la migrazione** (traccia d'audit, per memoria: il tag *è* già quell'albero): + +Variante **V1** (verificata pulita): + +```bash +cd /percorso/avalon +git fetch --all +git log --oneline -5 new_econs # per orientamento: docs, deps, /version e i commit di release sopra cefabdd +git checkout -b new_net_noecons new_econs +git revert --no-commit 46c77ff # nessun conflitto, nessun intervento manuale +git status --short # atteso: 5 M + D test/supply-anchor.js +git diff --stat # atteso: 6 file, 10 insertions(+), 432 deletions(-) +git commit -m "revert(econs): esclude il fork #13330000 da questa release" +``` + +Variante **V2** (stesso albero, storia lineare): + +```bash +git checkout -b new_net_noecons 46c77ff^ # = 9774aca +git cherry-pick 46c77ff..new_econs # tutti i commit sopra l'econs: + # docs, deps, /version, release e i fix + # commit di release (nessun conflitto atteso) +``` + +Controllo di equivalenza (in ogni variante — conferma anche il tag): + +```bash +# atteso: i 6 file dell'economia (+10/−432) più i 5 file della linea di release +# (src/http/auth/index.js, src/http/index.js, src/p2p.js, test/audit-fixes.js, +# test/image-sharp.js) — limitato al codice apposta: le revisioni di doc/ possono legittimamente differire +git diff new_econs v2.0.3 --stat -- src test scripts # oppure il tuo new_net_noecons +``` + +### S2 — Verifica statica, offline ⚠️ + +```bash +export PATH="...node24/bin:$PATH" # Node >= 24 +npm ci # o npm install se il lock non è allineato + +# 1. Nessun residuo dell'economia +grep -rn "rewardPoolYearlyRate\|vtReferenceTotal\|initialSupplyBlock\|totalSupplyUnits\|13330000" \ + src test scripts 2>/dev/null +# atteso: nessun output. doc/ NON viene scansionata apposta: economics_fork_13330000.md +# e i documenti di migrazione discutono quei simboli di proposito (la versione precedente +# di questo comando scansionava doc/ e l'esclusione non matchava il nome di questo file). + +# 2. La config all'altezza del fork non attiva più nulla, e il resto resta +node -e 'global.logr=new Proxy({},{get:()=>()=>{}});global.cache={state:{}}; +const c=require("./src/config.js"); +const p=c.read(13330000), f=c.read(13325000); +console.log("econs:",p.rewardPoolYearlyRate,p.vtReferenceTotal,p.initialSupplyBlock, + "| pool:",p.rewardPoolAmount,"| FF@13325000:",f.forceFinalize,"| sigVer:",f.consensusSigVersion)' +# atteso: econs: undefined undefined undefined | pool: 150001 | FF@13325000: true | sigVer: 2 + +# 3. Gate qualità +npm run lint # atteso: 2 errori preesistenti curly (auth/index.js:90, p2p.js:533) + ~251 warning +node test/audit-fixes.js # atteso: 24 passed, 0 failed +node test/force-finalize.js # atteso: All tests passed +# test/supply-anchor.js: NON deve esistere (il revert lo elimina; nella V3 va cancellato a mano) + +# 4. Confermare di essere sul tag di release certificato +git describe --tags # atteso: v2.0.3 +``` + +### S3 — Config, ambiente, proxy 🔴 + +Il nuovo codice aggiunge **18 variabili d'ambiente** (ricontate il 2026-10-20: l'albero passa da 45 a 63 riferimenti `process.env`) e **non ne rimuove nessuna**. Cinque di queste cambiano il comportamento di *default* rispetto a `new_net` e possono rompere i client se ignorate: + +| Variabile | Default nuovo | `new_net` | Perché importa | +|---|---|---|---| +| `CORS_ORIGIN` | **`false`** → nessun header CORS | `cors()` = `*` | 🔴 **il client web (dtube2) non riesce più a leggere le risposte API cross-origin**. Da impostare (es. `*`, o l'origine del client) | +| `HTTP_HOST` | **`127.0.0.1`** | `0.0.0.0` | 🔴 API non raggiungibile dall'esterno/dal container se non la si imposta esplicitamente (il `docker-compose.yml` la passa già) | +| rate limit globale | **50 req/s per IP** (nuovo) | assente | richieste massicce (feed, indexer, script) prendono `429`; `/transact` ha un limiter separato a **5 req/s** | +| `TRUST_PROXY` | non impostata → `X-Forwarded-For` **ignorato** | header fidato | 🔴 dietro nginx *tutti* i client condividono un solo secchiello → `429` di massa, e le sessioni admin risultano legate all'IP del proxy. Con valore sbagliato si riapre lo spoofing | +| body parser | **1 MB** | illimitato | payload grandi → `413` | + +Delle 18 variabili nuove, solo ~10 toccano il runtime del daemon (4 di esse sono i must-config di sicurezza/auth: `ADMIN_TOKEN`, `LOG_ADMIN_TOKEN`, `TRUST_PROXY`, `CORS_ORIGIN`; 4 sono limiti anti-abuso: `CONTENT_MAX_COMMENTS`, `CONTENT_MAX_RESULTS`, `IMG_MAX_BYTES`, `IMG_MAX_PIXELS`; 2 sono il log viewer in-nodo: `LOG_FULL`, `LOG_PAGE`), 6 sono parametri esclusivi dello script di halt-recovery (`BSON_PATH`, `IDX_PATH`, `REMOVE_COUNT`, `NEW_HEIGHT`, `DRY_RUN`, `TMP_COLL`), 1 è ops a runtime (`SKIP_EARLY_CHECK_BLOCKS`) e 1 è solo testnet (`BOOTSTRAP_HOST`). + +🔴 **Lacuna di scopribilità da chiudere prima del cutover**: **nessuna** delle nuove variabili è dichiarata in `scripts/start.sh` (che dichiara solo 12 export), benché il README indichi proprio lì "l'elenco delle variabili d'ambiente disponibili". Aggiungere in coda a `scripts/start.sh` (o consegnare un `.env.example`) un blocco commentato con le 18 nuove variabili e i loro default, così i operatori le trovano davvero. + +Altre variabili nuove, da valutare: `IMG_MAX_BYTES` (10 MB), `IMG_MAX_PIXELS` (20 MPixels), `CONTENT_MAX_COMMENTS` (2000), `CONTENT_MAX_RESULTS` (10000), `LOG_ADMIN_TOKEN` / `LOG_FULL` / `LOG_PAGE` (log viewer in-nodo), e le variabili usate solo dagli script di halt (`BSON_PATH`, `IDX_PATH`, `REMOVE_COUNT`, `NEW_HEIGHT`, `DRY_RUN`, `SKIP_EARLY_CHECK_BLOCKS`, `TMP_COLL`, `BOOTSTRAP_HOST`). + +Autenticazione: nel nuovo codice `requireAuth()` protegge `/debug`, `/recover`, `/logs`, `/mineBlock`. Dal `v2.0.3` questi endpoint sono **fail-closed**: senza token configurato rispondono `401`, quindi un nodo non configurato non li serve più in anonimo. Impostare `ADMIN_TOKEN`/`LOG_ADMIN_TOKEN` prima di esporre il nodo; solo l'uso locale deliberato dovrebbe impostare `ADMIN_ALLOW_ANONYMOUS=1` (il `docker/testnet` locale fa esattamente questo). + +Dietro reverse proxy: + +```nginx +proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; +proxy_set_header X-Forwarded-Proto $scheme; +# poi nel .env del nodo: +TRUST_PROXY=1 # "1" = primo hop fidato; 0/false = non fidarsi (default) +CORS_ORIGIN='*' # o l'origine esatta del client web +HTTP_HOST=0.0.0.0 +``` + +Docker: `docker/docker-compose.yml` ha perso `version:` e ora passa `HTTP_HOST=0.0.0.0`. Node è allineato a **24** ovunque dal `v2.0.2`: immagine mainnet (`docker/Dockerfile`, NodeSource `setup_24.x`), immagine testnet (`docker/testnet/Dockerfile`, `FROM node:24`), `docker/test.dockerfile` (`node:24-alpine`) e il guard di avvio in `main.js` (`>= v24`) — tutto coerente con `engines: node >= 24` (R8 chiuso). + +### S4 — Dry-run su testnet locale ⚠️ + +Prima di toccare la mainnet, riprodurre la migrazione su `docker/testnet` (3 miner + bootstrap, porte 3101-3104 / 6101-6104): + +1. checkout del tag di release e build (`git checkout v2.0.3 && docker compose build`); +2. catena da zero: verifica che i blocchi si producano e che nei log **non compaia mai** `Hard Fork #13330000`; +3. **prova di determinismo**: rebuild completo da genesis sul codice nuovo-senza-economia e confronto di un centinaio di hash di blocco con un nodo `new_net` → devono coincidere (i validatori sono cambiati, R2); +4. test force-finalization (due `/mineBlock` quasi simultanei su miner diversi); +5. test di un nodo di controllo che si sincronizza da zero (replay + accumulatore non coinvolto). + +### S5 — Flag day: cutover mainnet 🔴 + +Ordine non negoziabile: **prima si ferma tutto, poi si tronca/riprende, poi si riparte con un solo codice**. + +```bash +# 1. Congelamento: fermare TUTTI i leader (coordinato, chat/voice aperta) +# - nessun nodo deve restare su new_net +# 2. Diagnosi dell'halt (sempre in dry-run per primo) +DRY_RUN=1 ./scripts/auto_resolve_halt.sh +# Lo script tronca blocchi (BSON o Mongo) e riscrive lo stato. +# Guardrail da conoscere: MAX_REMOVE_BLOCKS (10), MAX_TOTAL_REMOVE (30) e +# .avalon_halt/state.json → se la catena non è avanzata dall'ultimo troncamento +# lo script RIFIUTA di troncare di nuovo ("Manual intervention required"). +# 3. Start della nuova versione su tutti i nodi (stesso commit!) +cd /percorso/avalon +export HTTP_HOST=0.0.0.0 CORS_ORIGIN='*' TRUST_PROXY=1 ADMIN_TOKEN=... LOG_ADMIN_TOKEN=... +nohup ./scripts/start.sh > /var/log/avalon.log 2>&1 & # o systemd / pm2 / screen +``` + +### S6 — Verifica post-cutover (checklist) + +```bash +curl -s localhost:3001/count # head che AVANZA (13.320.068+) +curl -s localhost:3001/block/13320068 | head -c 200 # phash = hash del 13320067 +curl -s localhost:3001/supply | head -c 200 # sanità (endpoint invariato, non econs) +curl -s localhost:3001/version # atteso: {"version":"2.0.3"} — IDENTICO su ogni nodo +grep -c "Hard Fork #13330000" /var/log/avalon.log # atteso: 0 (per sempre) +grep "Hard Fork #" /var/log/avalon.log | tail -3 # attesi solo 241600 (e 13325000 dal futuro fork) +``` + +Più, sul nodo di controllo: rebuild da genesis → stesso head **e stesso hash** degli altri nodi. Formato payout/voti: invariato (pool = 150001). Primo giorno intero di osservazione: `/count` monotono, nessun `possBlocks` crescente, peer stabili. Ogni operatore esegue `curl -s localhost:3001/version` e riporta il risultato nella chat di cutover: tutti i nodi devono rispondere `2.0.3`. + +### S7 — Client, indexer, embed + +- **Nessuna modifica client necessaria per escludere l'economia**: il fork non tocca nessun endpoint HTTP (`46c77ff` non modifica `src/http/**`) e `/supply` resta quello di prima. +- **Ma**: `CORS_ORIGIN` va impostata su *tutti* i nodi pubblici, altrimenti dtube2 (browser) non legge le risposte. +- `client/settings.js` → `AvalonAPINodes` (`api.avalonblocks.com`, `dtube.fso.ovh`, `avalon.luminade.fun`, `dtube.tekraze.com`, `testnet.dtube.fso.ovh`, più una voce dev locale `localhost:3001`): ognuno di questi nodi va aggiornato e configurato, altrimenti il client continua a parlare con istanze vecchie. +- Rate limit: `/transact` 5 req/s per IP e globale 50 req/s → verificare i flussi che inviano più transazioni in raffica (batch di voti/upload da dtube2) e prevedere retry/backoff lato client. +- `javalon2`: il nodo passa da `^1.1.7` a `^1.1.10` (bump del 2026-10-20, commit `04ad87b`; la 1.1.10 aggiunge il fix di fallback sul DMCA endpoint e bump di dipendenze compatibili), ma **non lo usa per la validazione di consenso** (usa `secp256k1` diretto: nessun impatto sulla catena; serve solo a `scripts/mega_generic_test.js`). Il bump cambia `signVerify` lato JS (ricostruzione dell'hash + rifiuto di `pubKey`/`signature`/`hash` mancanti): verificare gli script/tool terzi che firmavano con la vecchia formulazione. +- `dtube-embed`, `ipfs-caching`, `DTubeGo` non sono coinvolti in questa migrazione. + +### S8 — Sorveglianza e secondo flag day (13.325.000) + +- Entro **13.325.000** (4.933 blocchi ≈ **4 h** a 3 s dall'attuale head — appena sopra il blocco di ripresa, sfruttando l'halt) **tutti i nodi devono girare il nuovo codice**: quel fork abilita `forceFinalize` e passa `consensusSigVersion` a 2 (serializzazione a chiavi ordinate). Un nodo rimasto indietro non produce/valida le stesse firme → fork o halt. +- Fino a quel blocco la rete ha **forza-finalization disabilitata**: un nuovo halt si risolve solo con `auto_resolve_halt.sh`. +- Da monitorare: `Hard Fork #13325000` nei log al momento giusto, health dei peer, eventuali `possBlocks` multipli. +- **Backlog post-migrazione** (audit dipendenze 2026-10-20): `apidoc` `^1.2.0` → `^0.29.0` (solo dev) resta un commit successivo, fuori dal delta. Il bump `sharp` `^0.32.6` → `^0.35.5` (high: CVE libvips/libheif sull'endpoint di processing immagini utente) **non è più rinviato** — ora viaggia **dentro il delta del flag day** (richiesto su Node ≥ 24 e per le CVE) ed è fissato dal `package-lock.json` committato. Ogni nodo deve eseguire `npm ci` dal lockfile e passare `node test/image-sharp.js` (upload+resize); trattarlo come un cambio R14. + +### S9 — Rollback + +- **Rollback immediato** (prima di produrre blocchi con il nuovo codice): stop → `git checkout` del commit precedente → restart. Costo: i minuti di fermo. +- 🔴 **Dopo che il nuovo codice ha validato blocchi**: tornare a `new_net` significa **troncare fino al blocco di cutover**, perché `new_net` non conosce le correzioni di validazione introdotte dal nuovo codice (R2/R3). Serve il backup di S0 e lo stesso `auto_resolve_halt.sh`. +- Salvare per poter tornare indietro: `blocks.bson`/dump Mongo, commit precedente, `.env`, `.avalon_halt/state.json`, log del periodo. + +--- + +## 5. Rischi + +| # | Rischio | Impatto | Prob. | Mitigazione | +|---|---|---|---|---| +| **R1** | Esclusione applicata solo ad alcuni nodi → al blocco 13.330.000 alcuni applicano il fork e altri no: `dist`/pool diversi, **catena divisa** | 🔴 critico | media | flag day con tutti i leader; verifica S2 (one-liner su ogni nodo) + `grep "Hard Fork #13330000"` = 0 + `curl /version` = 2.0.3 su ogni nodo; nessun nodo `new_net` online | +| **R2** | Il nuovo codice cambia **validatori** (`validate/json.js`, `float.js`, `integer.js`, `string.js`, controllo bandwidth su create-account, bound dimensione blocchi, JSON con chiavi `.`/`$` rifiutate): un blocco/tx accettata dai vecchi può essere rifiutata dai nuovi | 🔴 fork o rebuild impossibile | alta se il cutover non è coordinato | testnet S4 con rebuild di controllo e confronto hash; cutover simultaneo; nessun nodo misto | +| **R3** | Rollback dopo blocchi post-cutover: la vecchia versione non riesce a validare la catena nuova | 🔴 perdita dati | media | definire in D4 il punto di non ritorno; backup S0; troncamento mirato S9 | +| **R4** | `CORS_ORIGIN` non impostata (default `false`) → il client web non legge le API | 🔴 client rotto | alta | impostarla su tutti i nodi pubblici (S3, S7) | +| **R5** | `HTTP_HOST` default `127.0.0.1` → API non raggiungibile dall'esterno | 🔴 servizio down | media | impostare `HTTP_HOST=0.0.0.0` (S3) e verificare da fuori, non solo da localhost | +| **R6** | Rate limit globale 50 r/s + `TRUST_PROXY` non impostata dietro proxy: un solo secchiello per tutti → `429` di massa; sessioni admin legate all'IP del proxy | 🟠 degrado/abuso | alta | `TRUST_PROXY` corretta + header nginx; valutare limiti in nginx; monitorare i `429` | +| **R7** | Rate limit su `/transact` (5 r/s) rompe flussi batch di dtube2 | 🟠 tx perse | media | backoff/retry client; verificare i flussi di voto/upload | +| **R8** | Node: `engines >= 24` ma immagini Docker su **Node 18** (`docker/Dockerfile`, `docker/testnet/Dockerfile`) e check runtime `>= 18` — trovato in validazione | 🟠 install/runtime non supportato | bassa *(chiuso)* | **chiuso in `v2.0.2`**: immagini allineate (`setup_24.x`, `FROM node:24`, `node:24-alpine`) e guard di `main.js` portato a `>= v24`; validare con `npm ci` su Node ≥ 24 | +| **R9** | Riattivare l'economia in futuro toccando `initialSupplyBlock`/`initialSupply` (anchor frozen, filtrato da `allowedKeys`) | 🔴 fork silenzioso | bassa | nuova entry di fork con altezza futura e anchor misurato; mai spostare le chiavi esistenti (appendice C) | +| **R10** | `eco.totalSupplyUnits` non bootstrappato → `logr.fatal` + `process.exit(1)` al primo blocco del fork (per un nodo che attraversa l'anchor senza ripartire) | 🟠 nodo che muore | bassa (esclusa in questa migrazione) | è il motivo per cui l'anchor è al tip attuale: riavvio di tutti i nodi in occasione della ripartenza | +| **R11** | Halt non risolto: force-finalization **non è attiva** fino a 13.325.000; i guardrail dello script (max 10 blocchi per passata, 30 totali, stato `.avalon_halt`) possono rifiutare il troncamento | 🔴 catena ferma | media | `DRY_RUN=1` prima, pianificare l'intervento manuale, backup S0, finestra di manutenzione concordata | +| **R12** | Senza la nuova economia restano aperti: ceiling di emissione 28,7 %/anno con pool costante `150001`, e il **drenaggio del pool da parte di una singola whale** su rete inattiva (bug di value extraction, `economics_fork_13330000.md` §2) | 🟠 economico | certa | decisione di business esplicita e datata (D3): riattivare con un fork successivo | +| **R13** | `scripts/start.sh` contiene una **chiave privata in chiaro** (`NODE_OWNER_PRIV=34Ep…`) su entrambi i branch, e nella storia ci sono commit "rimuovi chiavi private" poi annullati | 🔴 sicurezza | certa | ruotare la chiave del nodo prima di diffondere questo documento o il branch; non versionare `start.sh` reale | +| **R14** | Bump dipendenze (`mongodb` 4.2→4.17, `secp256k1`, `express`, ora `javalon2` ^1.1.10, e `sharp` ^0.35.5 che ora viaggia **dentro il delta del flag day**): comportamento/indici diversi su DB esistenti | 🟠 errori a runtime | media | test su copia del DB; leggere i log al primo avvio; `npm ci` da lockfile; per `sharp` eseguire `node test/image-sharp.js` (upload+resize) su ogni nodo | +| **R15** | Il nuovo codice *è* una release anti-halt (consensus.js 290→684 righe) ma la force-finalization è disattivata fino a 13.325.000: la stabilità della ripresa dipende dalla nuova logica non ancora esercitata in produzione | 🟠 nuovo halt | media | testnet di force-finalization (S4); `auto_resolve_halt.sh` pronto; osservazione ravvicinata (S8) | + +--- + +## 6. Definition of done + +- [ ] Tag checkoutato su ogni nodo (`git checkout v2.0.3`) e `git diff new_econs v2.0.3 --stat -- src test scripts` mostra i 6 file dell'economia **più** i fix della linea di release (`src/http/auth/index.js`, `src/http/index.js`, `src/p2p.js`, `test/audit-fixes.js`, `test/image-sharp.js`) +- [ ] `grep` residui e one-liner config di S2 → esito atteso (nessuna chiave econs, `pool: 150001`, `FF@13325000: true`, `sigVer: 2`) +- [ ] `npm run lint` + `test/audit-fixes.js` + `test/force-finalize.js` verdi come da baseline +- [ ] Node ≥ 24 su tutti i nodi e nelle immagini Docker +- [ ] Ogni nodo sul tag certificato (`git describe --tags` = `v2.0.3`); `curl /version` restituisce `2.0.3` su ogni nodo +- [ ] `CORS_ORIGIN`, `HTTP_HOST`, `TRUST_PROXY`, `ADMIN_TOKEN`/`LOG_ADMIN_TOKEN` impostate e verificate **da fuori rete locale** +- [ ] Nuove env vars dichiarate in `scripts/start.sh` (blocco commentato) perché i operatori possano scoprirle +- [ ] Dry-run su testnet: rebuild da genesis con hash coincidenti + force-finalization testata +- [ ] Backup di blocchi, DB, `.env`, commit precedente in luogo sicuro e verificato +- [ ] Tutti i leader fermi, nessuno su `new_net`, chat di cutover aperta +- [ ] Dopo il cutover: `/count` avanza, hash di catena coerenti su tutti i nodi, **zero** `Hard Fork #13330000` nei log +- [ ] Calendario condiviso con la rete: entro il blocco **13.325.000** tutti sul nuovo codice +- [ ] Chiave privata di `scripts/start.sh` ruotata + +--- + +## 7. ⏱ Stime di esecuzione + +Tempo di presidio umano per passo, stimato sul layout reale del nodo mainnet (`blocks.bson` 4,2 GB + 102 MB index, Mongo ~2,7 GB): + +| Passo | Presidio | Su cosa si basa | +|---|---|---| +| **S0 pre-flight** | **~15 min** | copia blocks.bson/index ≈ 1–2 min (4,3G su disco locale/1Gbit), `mongodump` 2,7G ≈ 2–3 min, snapshot git/env/chiavi ~5 min | +| **S1 checkout della release** | **~1 min** | `git checkout v2.0.3` (tag già certificato; le varianti di self-build sono solo audit) | +| **S2 verifica statica** | **~10–15 min** | `npm ci` 1–5 min (a cache), grep + one-liner config + lint + 2 suite di test | +| **S3 config/proxy** | **~30 min per nodo** | `.env` + blocco commentato nuovo in `start.sh` + nginx (`X-Forwarded-For`) + verifica dall'esterno | +| **S4 dry-run testnet** | **~1–2 h al primo giro**, ~45 min a ripetizione | `docker compose build` 15–30 min la prima volta; catena da zero, rebuild di determinismo, test force-finalization | +| **S5 flag day** | **finestra ~45–60 min** | stop di tutti i leader 10–15, diagnosi `DRY_RUN=1` 5–10, troncamento/restart 10–15, verifica primo blocco 10–15 | +| **S6 post-cutover** | **~15 min + 1–4 h non presidiate** | checklist curl; il rebuild da genesis sul nodo di controllo gira in background (13,3M blocchi) | +| **S7 client/indexer** | **~1 h** | `CORS_ORIGIN` su ogni nodo pubblico di `AvalonAPINodes` (~10–15 min ciascuno) + check flussi batch dtube2 | +| **S8 sorveglianza** | **~15 min in totale** | fino a 13.325.000 (≈4 h dopo la ripresa), monitoraggio leggero | +| **S9 piano rollback** | **~30 min** | decisione D4 + backup già coperti da S0 | + +Totali: +- **Un operatore sul proprio nodo: ~4–6 ore di presidio** (di cui ~1 h è la finestra di cutover), più 1–4 h di rebuild non presidiato e ~4 h di osservazione leggera. +- **Calendario realistico: 2 giornate** — una per S0–S4 (dry-run su testnet), una per il flag day S5–S6 — più la finestra concertata con gli altri leader. +- Il lavoro critico è tutto in **S0–S3 + S5 (~2 h)**: il resto è attesa o monitoraggio. + +--- + +## Appendice A — Cosa c'è nel nuovo codice (misurato il 2026-10-20) + +168 commit / 102 file / +5131 −801 misurati a `cefabdd` (la vecchia punta di codice); alla punta di codice `6cc3b46`: 181 commit / 106 file / +5604 −812 — sopra `cefabdd` solo non-consenso (docs, bump javalon2, endpoint `/version`, release 2.0.0–2.0.2; i file in più rispetto a `cefabdd` sono l'`doc/v1.5.2-upgrade.md` aggiornato, questo runbook e `src/http/version/`). + +| Blocco | Esempi | +|---|---| +| Consenso / anti-fork | force-finalization con quorum, backoff, firma verificata, broadcast; `forceFinalizeFallback` (default `false`: la catena si ferma invece di rischiare un fork); `consensusSigVersion: 2` gated a 13.325.000 | +| Recupero halt | `scripts/auto_resolve_halt.sh` (794 righe), troncamento BSON/Mongo, guardrail anti-loop | +| Sicurezza HTTP | SSRF (`src/http/ssrf.js`, pinning IP/TLS), validazione input, cap su query, rate limit globale e per-endpoint, `requireAuth` condiviso, sessioni legate all'IP, redazione log/credenziali | +| Rete P2P | cap payload websocket, rate limiter dedicato, TTL su `blockSenders`, cleanup O(1) | +| Robustezza cache/blocchi | scrittura atomica dello stato, error handling coda Mongo, BSON troncato gestito, `sanitizeQuery` | +| Validatori | `float`/`integer`/`string`/`json` (NaN/Infinity, chiavi `.`/`$`, bound a zero), dimensione JSON in byte | +| Piattaforma | Node ≥ 24, `docker/testnet` multi-nodo, log viewer in-nodo, endpoint `/version`, `javalon2` 1.1.10 | +| Economia (l'unica esclusa) | commit `46c77ff` | + +## Appendice B — Timeline hard fork + +| Altezza | Contenuto | Stato | +|---|---|---| +| 0 | config base (`rewardPoolAmount: 150001`, `rewardPoolMaxShare: 0.1`, …) | attiva | +| 241600 | `txLimits` | attiva | +| 13.320.067 | head attuale (catena ferma dal 2026-06-27; rimisurato 2026-10-20: invariato) | — | +| **13.330.000** | **economia: pool % supply + cap voto + accumulatore** | **da escludere (mai attivata: mancano 9.933 blocchi ≈ 8,3 h a 3 s)** | +| 13.325.000 | `forceFinalize: true`, `consensusSigVersion: 2` | si attiva ≈4 h dopo la ripresa (era ~21 giorni; abbassata a catena ferma) | + +## Appendice C — Invarianti dell'economia (se un giorno si riattiva) + +- `initialSupplyBlock: 13320066` / `initialSupply: 572311976.600145` sono **misure frozen** e sono **filtrate da `allowedKeys`**: la governance non può riscriverle, solo una nuova entry di fork può. +- Mai spostare quelle chiavi tra entry di history: cambierebbe `config.read(n)` per blocchi già prodotti. +- `bootstrapSupply()` (upgrade/riavvio) ricostruisce l'accumulatore con `chain.scanSupply(anchor+1 … head)` da BSON o Mongo: un nodo che riparte dopo l'anchor si auto-ripara; un nodo che *attraversa* l'anchor **senza** ripartire finisce in `logr.fatal` + `process.exit(1)`. +- Riattivare l'economia = nuovo fork con l'altezza futura desiderata (l'anchor 13.320.066 può restare, il costo è lo scan). + +## Appendice D — Comandi rapidi + +```bash +# Il mio checkout esclude davvero l'economia? (atteso: esattamente i 6 file) +git diff new_econs HEAD --stat -- src test scripts + +# Nessun residuo? (solo src/test/scripts — vedi S2 sul perché si esclude doc/) +grep -rn "rewardPoolYearlyRate\|vtReferenceTotal\|initialSupplyBlock\|totalSupplyUnits" src test scripts + +# Config all'altezza del fork + fork successivo intatto +node -e 'global.logr=new Proxy({},{get:()=>()=>{}});global.cache={state:{}};const c=require("./src/config.js"); +const p=c.read(13330000),f=c.read(13325000);console.log(p.rewardPoolYearlyRate,p.vtReferenceTotal,p.initialSupplyBlock,p.rewardPoolAmount,f.forceFinalize,f.consensusSigVersion)' + +# Stato della rete +curl -s https://dtube.fso.ovh/count + +# Stessa release su questo nodo? (atteso: 2.0.3) +curl -s localhost:3001/version + +# Il nodo ha attivato l'economia? (deve restare vuoto) +grep "Hard Fork #13330000" /var/log/avalon.log +``` diff --git a/doc/public-testnet.md b/doc/public-testnet.md new file mode 100644 index 0000000..456469e --- /dev/null +++ b/doc/public-testnet.md @@ -0,0 +1,311 @@ +# Avalon Public Testnet — Multi-Operator Guide + +**Status:** pre-launch (draft for coordinator review) +**Target release:** certified **`v2.0.3`** (branch `feat/auto-force-finalize`) — the *no-economy* line; hard fork `#13330000` is **not** included +**Audience:** independent operators (entities that run their own node on their own infrastructure, with their own keys) +**Companions:** [`mainnet-deployment-and-rollback.md`](./mainnet-deployment-and-rollback.md), [`migration-runbook-no-econs.md`](./migration-runbook-no-econs.md), local dev net in [`docker/testnet/README.md`](../docker/testnet/README.md) + +--- + +## 0. TL;DR + +A public testnet is a **separate chain** that runs the same certified code as the upcoming mainnet migration, but on a fresh genesis and with **different, testnet-only** values for the fields that define a chain. Every independent entity runs a real node on its own machine, over the public internet, and they must agree on **two things**: + +1. the **same commit** (the certified `v2.0.3` tag), and +2. the **same testnet config patch** (chain id, master key, fork heights). + +Miss either one and the entities end up on **different chains** that silently ignore each other. Everything else (ports, peers, own keys) is per-operator. + +The testnet exists to rehearse, with real independent operators, exactly what the mainnet flag day will do: multi-node P2P, leader rotation, force-finalization, halt recovery, the new HTTP security defaults, and Node 24. + +--- + +## 1. Scope — what this testnet is (and is not) + +| | | +|---|---| +| **Runs** | certified `v2.0.3`, Node.js ≥ 24, no economy fork (`#13330000` absent) | +| **Chain** | fresh, isolated chain; block `#0` is a fixed genesis; the master account (default `dtube`) holds the testnet supply | +| **Exercises** | multi-operator P2P, leader election/rotation, **force-finalization** (activated early), halt recovery, `CORS_ORIGIN`/`TRUST_PROXY`/rate limiting/auth, `/version` census | +| **Does NOT contain** | any mainnet balances, contents or history; any real value | +| **Must never reach** | mainnet peers, or any other chain (enforced by a **distinct `originHash`**, §4) | + +Owners and keys on the testnet are **throwaway**. Never reuse a mainnet key, and never point a testnet node at a mainnet MongoDB. + +--- + +## 2. Roles + +**Coordinator** (one entity, decided before launch): +- fixes and publishes the testnet config (§4), the peer list, and the launch height/date; +- holds the **master private key** and bootstraps the chain (§5); +- keeps an authoritative clock reference (NTP) and announces fork heights and upgrade windows. + +**Operator** (each independent entity): +- runs one or more nodes on its own infrastructure and network; +- owns its **own leader keypair**, separate from mainnet; +- reports `version` / `count` / `peers` on the shared channel at the agreed checkpoints. + +Coordination happens on one channel (Discord `DTube Chain → #leader-candidates`) plus a pinned launch message. Anything that changes consensus must be announced *before* it takes effect — same rule as the mainnet runbook. + +--- + +## 3. Prerequisites (per operator) + +- **Node.js ≥ 24** (`node -v`); `engines` requires it and `main.js` enforces it. +- **MongoDB** running locally (the docker dev net uses `mongo:6.0.2`). +- **NTP / chrony** active — block timestamps have a hard `maxDrift` of 200 ms. +- **Disk / RAM** for the chain DB and a `blocks.bson` directory. +- **Open ports**: HTTP (default `3001`) and P2P (default `6001`). To be reachable by other entities, the P2P port must be reachable from the internet; publish `ws://your-ip:6001` in your profile so discovery can find you. +- **A fresh node keypair**: `node src/cli.js keypair > my-testnet-key.json`. +- Docker + Compose v2 (optional) and `jq`/`curl` for the verification steps. + +--- + +## 4. The shared testnet configuration (identical on every node) + +The chain identity is entirely defined by fields in `src/config.js`. Because `#0` is a fixed genesis block whose hash is taken verbatim from `config.originHash`, these fields **are** the chain id. **Any** difference between two nodes means two chains. + +The testnet config patch (applied to `src/config.js` on **every** node, exactly once) changes: + +| Field | Why | Notes | +|---|---|---| +| `originHash` | **isolate the testnet.** The P2P handshake rejects any peer whose `origin_block !== config.originHash` (`src/p2p.js`), and catch-up only follows peers with a matching `origin_block`. A testnet-specific value means testnet and mainnet can never peer. | any fixed 64-char hex string; block `#0` inherits it | +| `block0ts` | genesis timestamp / bw-vt growth base | must be identical everywhere | +| `masterName` / `masterPub` / `masterPubLeader` | **key custody.** `mongo.insertMasterAccount()` creates the master from these; put a *fresh testnet keypair* here, not the mainnet key. | the coordinator keeps the master **private** key | +| `masterDaoTxs` | let the master create accounts, transfer, enable and vote on the fresh chain | widen as in the dev net | +| `forceFinalize` @ a **low** height | the whole point of the testnet: exercise the anti-fork safety net early (mainnet only enables it at `13 325 000`) | e.g. block `100` | + +Reference patch (this is exactly what `docker/testnet` does, plus the isolation/master keys): + +```js +// src/config.js — history[0] +originHash: '', // NOT the mainnet 89b3b9... value +block0ts: , +masterName: 'dtube', // testnet master account name +masterPub: '', // fresh key, mainnet key NOT allowed +masterPubLeader: '', +masterDaoTxs: [0,1,2,3,4,5,6,7,8,10,11,12,13,14,15,17,18,19,20,21,23,24,25,26,27,28,29,30,32], +// ...and in history, above 241600: +100: { forceFinalize: true }, +``` + +Also confirm **no** `13330000` entry exists (this line ships without the economy): + +```bash +grep -n "13330000\|rewardPoolYearlyRate\|initialSupplyBlock" src/config.js # must print nothing +``` + +> The coordinator publishes the patch text **and** the resulting `git diff src/config.js`, so an operator can verify byte-for-byte that their config matches. Two nodes with the same `originHash` but a different fork height will diverge at that height. + +--- + +## 5. Bootstrap (coordinator, once) + +Goal: produce block `#0` and the first blocks, then hand every operator an account. + +```bash +# 1. Fresh code at the certified tag, on the coordinator machine +git fetch --all --tags && git checkout v2.0.3 +npm ci + +# 2. Apply the shared testnet patch to src/config.js (§4), then confirm +git diff --stat src/config.js + +# 3. Start from a clean DB and NO genesis.zip: +# with no genesis.zip, initGenesis() inserts the master account + block #0 +mongosh avalon --eval "db.dropDatabase()" # or docker: drop the mongo volume +rm -rf ./genesis ./genesis.zip ./blocks/* + +# 4. Configure keys + ports + auth, then start +export HTTP_HOST=0.0.0.0 CORS_ORIGIN='*' ADMIN_TOKEN= LOG_ADMIN_TOKEN= +export NODE_OWNER=dtube NODE_OWNER_PUB= NODE_OWNER_PRIV= +./scripts/start.sh + +# 5. Kick production until the chain moves on its own. +# /mineBlock is fail-closed without a token, so send ADMIN_TOKEN (§7) +for i in $(seq 1 20); do curl -sf -H "Authorization: Bearer $ADMIN_TOKEN" localhost:3001/mineBlock; sleep 3; done +curl -s localhost:3001/count # must advance past #0 +``` + +Then create the operator accounts and fund them (master key): + +```bash +node src/cli.js account -K -M dtube +node src/cli.js transfer 100000 -K -M dtube +``` + +Alternatively (fast path for late joiners) the coordinator can publish a **database snapshot** of the bootstrapped state instead of asking everyone to replay from `#0`. A snapshot is not required for correctness here — unlike mainnet, a testnet node needs **no** `genesis.zip`, because block `#0` is deterministic and every node recomputes the same one from the shared config. + +Once the chain runs, publish on the shared channel: the tag, the exact config patch, the **bootstrap peer** (`ws://:6001`) and the launch height. + +--- + +## 6. Join (each operator) + +```bash +git clone https://github.com/dtube/avalon.git && cd avalon +git fetch --all --tags && git checkout v2.0.3 +npm ci + +# Apply the coordinator's testnet config patch (§4). Verify it matches theirs: +git diff src/config.js # compare with the published diff + +# Clean slate: no mainnet data, no leftover genesis.zip +mongosh avalon --eval "db.dropDatabase()" +rm -rf ./genesis ./genesis.zip ./blocks/* +mkdir -p blocks && export BLOCKS_DIR=$(pwd)/blocks +``` + +Set the environment (§7), then start `./scripts/start.sh`. The node creates the master account, the deterministic block `#0`, connects to the bootstrap peer and syncs via catch-up. Confirm with `/count`, `/peers` and `/schedule`. + +To be discoverable, publish your P2P endpoint in your profile (optional but recommended for a public net): + +```bash +node src/cli.js profile -K -M '{"node":{"ws":"ws://:6001"}}' +``` + +--- + +## 7. Environment variables that matter + +The `v2.0.x` line adds secure-by-default behaviour and **can break clients or lock out peers** if unset. Set at least these (the `docker/docker-compose.yml` shows a working set): + +| Variable | Default | Testnet value | Why | +|---|---|---|---| +| `HTTP_HOST` | `127.0.0.1` | `0.0.0.0` | reachable from outside / other services | +| `CORS_ORIGIN` | `false` (no CORS) | `*` (or the client origin) | browsers get nothing cross-origin otherwise | +| `TRUST_PROXY` | off (`X-Forwarded-For` ignored) | `1` | only behind a reverse proxy; **not** set = rate-limit bucket shared by all clients | +| `ADMIN_TOKEN` / `LOG_ADMIN_TOKEN` | unset → privileged endpoints return **401** (fail closed) unless `ADMIN_ALLOW_ANONYMOUS=1` | a real token | `/mineBlock`, `/recover`, `/debug`, `/logs` need `Authorization: Bearer ` | +| `HTTP_PORT` / `P2P_PORT` | `3001` / `6001` | your choice | expose the P2P port to the internet | +| `PEERS` | empty | `ws://:6001` (+ others) | initial connectivity | +| `MAX_PEERS` | `15` | `50`+ if you are a public node | discovery fan-in | +| `NODE_OWNER` / `NODE_OWNER_PUB` / `NODE_OWNER_PRIV` | — | your testnet key | required to produce / vote | +| `NO_DISCOVERY` | off | leave off for a public net | discovery is what makes it a network (the *local* docker net sets `NO_DISCOVERY=1`) | +| `LEADER_STATS` | off | `1` (optional) | per-leader produced/missed counters | + +Notes: +- The global HTTP rate limit is **50 req/s per IP**; `/transact` has its own **5 req/s** limiter; the JSON body cap is **1 MB**. Test batch flows against these before declaring the testnet healthy. +- **Never commit a `start.sh` containing `NODE_OWNER_PRIV`.** Put keys in an untracked `.env` or export them at start. + +--- + +## 8. Becoming a leader + +Leader eligibility is by votes (`node_appr`). On a testnet with a handful of entities, coordinate a sensible leader set (`leaders: 5` in config): + +```bash +# 1. generate a leader key (per operator) +node src/cli.js keypair > leader-key.json + +# 2. associate it on-chain (signed by the account master key, or an authorised key) +node src/cli.js enable-node -M -K + +# 3. vote (the master can vote for everyone on the testnet) +node src/cli.js vote-leader -M dtube -K +``` + +If fewer than `leaders` accounts are eligible, `minerSchedule()` pads the shuffle with repeats, so a small testnet still produces blocks. Keep the leader set small and agreed; a public P2P net with too few leaders is slow to notice liveness problems. + +--- + +## 9. Verification checklist (must pass on every node) + +```bash +curl -s localhost:3001/version # {"version":"2.0.3"} — IDENTICAL on every node +curl -s localhost:3001/count # head advances monotonically +curl -s localhost:3001/peers # peers from independent entities +curl -s localhost:3001/schedule # leader shuffle is present and consistent + +# continuity +H=$(curl -s localhost:3001/count | tr -d '"') +curl -s localhost:3001/block/$H | grep -o '"phash":"[^"]*"' +curl -s localhost:3001/block/$((H-1)) | grep -o '"hash":"[^"]*"' # must match + +# no economy fork, ever +grep -c "Hard Fork #13330000" /var/log/avalon.log # expected: 0 +grep "Hard Fork #" /var/log/avalon.log | tail -3 # 241600, then forceFinalize at the chosen height +``` + +**Determinism check** (the reason a testnet is worth running before the flag day): on a control node, rebuild from genesis on the same commit and confirm it reaches the **same head and the same block hashes** as a running node: + +```bash +REBUILD_STATE=1 ./scripts/start.sh +``` + +**Force-finalization drill** (only after the `forceFinalize` height): trigger two near-simultaneous blocks on two different miners and confirm the network converges: + +```bash +curl -sf -H "Authorization: Bearer $ADMIN_TOKEN" http://:3001/mineBlock & \ +curl -sf -H "Authorization: Bearer $ADMIN_TOKEN" http://:3001/mineBlock & +# then watch: +watch -n1 'curl -s http://:3001/count' +grep -i "force\|collision" /var/log/avalon.log +``` + +--- + +## 10. Failure drills worth running + +The testnet is only useful if it is pushed into the failure modes the mainnet runbook cares about: + +| Drill | Do | Expected | +|---|---|---| +| Leader offline | stop one leader node for ~100 blocks | chain continues via the fallback ladder; no halt | +| Clock skew | shift one node's clock ±5 s | blocks delayed then accepted; no peer ban, no divergence | +| Partition | cut network between two groups | majority keeps producing; minority resyncs by catch-up (`recover()`), no divergent height | +| Collision | two `/mineBlock` on different miners (§9) | deterministic winner, chain resumes | +| Halt recovery | stop enough leaders to stall | `DRY_RUN=1 ./scripts/auto_resolve_halt.sh` first, then coordinate (see the mainnet runbook §"Emergency") | +| Old node | run one node on the previous commit | it must lag, never fork; upgrade it | + +Assert that all nodes agree on `count` and block hashes after each drill. A drill that "passes" while two nodes disagree is a failed drill. + +--- + +## 11. Upgrade, tag changes and rollback + +- **Everyone runs the same commit.** A new tag on the testnet is a coordinated event: announce it, agree on an upgrade height/window, and upgrade all nodes together. Mixing commits can change validators and split the chain (mainnet runbook, R2). +- **Rollback** = stop, `git checkout` the previous commit, restore the pre-change MongoDB snapshot and `blocks.bson`. As on mainnet, once the new commit has validated blocks, going back means truncating or restoring — keep snapshots before every change. +- **Do not add `config.history` entries** (or bump fork heights) without a coordinated, announced height; heights in `history` are immutable once passed. + +--- + +## 12. House rules + +- **Testnet keys only.** Every key here is disposable; never sign anything with a mainnet key on the testnet. +- **One channel, one source of truth.** The coordinator's pinned message holds the tag, the config patch, the peer list and the current launch/height state. +- **Report on checkpoints.** Each operator posts `version`, `count`, `peers` at the agreed checkpoints and after every drill. +- **Halt, don't fork.** If the network splits, stop and coordinate — do not truncate or restart a divergent node on your own. +- **Isolate.** If you ever see a peer you cannot account for, check `origin_block` in your logs (`Different chain id, disconnecting`); a wrong `originHash` is the usual cause. + +--- + +## Appendix A — quick reference + +```bash +# chain id / isolation +grep -n "originHash\|block0ts\|masterPub\|masterName" src/config.js +grep -n "13330000" src/config.js # must be empty + +# what a node is doing +curl -s localhost:3001/version +curl -s localhost:3001/count +curl -s localhost:3001/peers +curl -s localhost:3001/schedule + +# healthy startup / no misconfig +grep -iE "error|fatal" /var/log/avalon.log | tail -20 +grep -c "Different chain id, disconnecting" /var/log/avalon.log + +# CLI used in this guide +node src/cli.js keypair > leader-key.json +node src/cli.js account -K -M dtube +node src/cli.js transfer 100000 -K -M dtube +node src/cli.js enable-node -M -K +node src/cli.js vote-leader -M dtube -K +node src/cli.js profile -K -M '{"node":{"ws":"ws://:6001"}}' +``` + +## Appendix B — difference from the local dev net + +`docker/testnet/` (3 miners + bootstrap on one host, `NO_DISCOVERY=1`, shared Mongo, dev keys) is a **single-machine smoke test**. This guide is the **multi-operator public** counterpart: separate infrastructure, separate Mongo, separate keys, real P2P and discovery, and an isolated chain id. Reuse the dev net to rehearse the exact commands; use this guide to run the real thing. diff --git a/doc/testnet-migration-test.en.md b/doc/testnet-migration-test.en.md new file mode 100644 index 0000000..d0342ac --- /dev/null +++ b/doc/testnet-migration-test.en.md @@ -0,0 +1,265 @@ +# Testnet dry run — migrating from `new_net` to the new code + +**Type**: test procedure · **Companion**: `doc/migration-runbook-no-econs.en.md` (step **S4**) + +**Goal**: rehearse the `new_net` → `feat/auto-force-finalize` upgrade on a local +testnet, on the same data, and verify chain continuity, determinism, the new +code paths and the anti-fork safety net. Nothing here touches mainnet — this is +the rehearsal that must pass before step **S5** (the mainnet cutover). + +## 0. Pass criteria + +| # | Check | Pass criterion | +|---|-------|----------------| +| 1 | Continuity | after the switch the chain resumes from the same head; new blocks link to it via `phash` | +| 2 | Version | `/version` is identical on **every** node and equals the release version | +| 3 | No economy | `Hard Fork #13330000` never appears in the logs | +| 4 | State preserved | the balance canaries (`s4alice`/`s4bob`/`s4carol`) keep their balance across the switch | +| 5 | New paths | post-migration activity works, including the new create-account bandwidth check | +| 6 | Force finalization | two concurrent blocks are resolved deterministically, with no split | +| 7 | Negative parity | `comment-edit` is still rejected (disabled by `txLimits`) | +| 8 | Determinism | a chain rebuilt with the new code matches the `new_net` block hashes | + +If any check fails, stop and treat it as a mainnet blocker (**R2** in the +runbook: a validator change that rejects an already-produced block means fork +or impossible rebuild). + +## 1. Topology, and how the testnet maps to the migration + +| Service | HTTP (host) | P2P (host) | Container | +|---------|-------------|------------|-----------| +| bootstrap | `:3101` | `:6101` | `avalon-testnet-bootstrap` | +| miner1 | `:3102` | `:6102` | `avalon-testnet-miner1` | +| miner2 | `:3103` | `:6103` | `avalon-testnet-miner2` | +| miner3 | `:3104` | `:6104` | `avalon-testnet-miner3` | +| mongodb | `:37017` | — | `avalon-testnet-mongodb` | + +The compose file bind-mounts `../../src` and `./scripts` into the containers, +so **the nodes run whatever is checked out in the working tree**. Switching code +version is therefore a `git checkout` followed by a restart — not an image +rebuild. `node_modules` are baked into the image, so a change to `package.json` +(for example the `sharp` bump) *does* require `docker compose build`. + +The migration uses the overlay `docker-compose.migrate.yml`, which replaces the +bootstrap command only: + +```yaml +command: ["bash", "-c", "node /avalon/scripts/s4-patch.js && exec node --stack-size=65500 src/main"] +``` + +The reason: the normal `testnet-genesis.sh` **drops the database on every +start**, which would destroy chain continuity. The migration must restart the +node on the existing data instead, applying the testnet-only config patch +(`s4-patch.js`) first. + +## 2. Running the commands + +All `docker compose` commands below run from `docker/testnet`, because the +compose file uses relative paths (`../../src`, `./scripts`). `git` commands run +from the repository root. + +Throughout, `` is the release candidate — the `v2.0.x` tag once it +is cut, or the branch `feat/auto-force-finalize` before tagging. + +A small helper is used to read a value out of the JSON responses (no `jq` +needed, `node` may not be on the host either): + +```bash +# count: GET /count -> {"count":N}; prints 0 if the node is unreachable +count() { local n; n=$(curl -sf "http://localhost:$1/count" | sed -n 's/.*"count":$[0-9]*$.*/\1/p'); echo "${n:-0}"; } +``` + +## 3. Phase A — baseline on `new_net` + +```bash +git checkout new_net +cd docker/testnet +docker compose build +docker compose up -d + +# wait for the chain to advance +until [ "$(count 3101)" -gt 50 ]; do sleep 2; done + +# freeze the reference head +HEAD_A=$(count 3101) +echo "baseline head: $HEAD_A" +``` + +Record the reference block hashes. A block does not store its own hash in a +directly readable field: it is stored as the **`phash` of the next block**, so +the hash of height `h` is `GET /block/h+1` → `phash`. + +```bash +: > /tmp/hashes-new_net.txt +for h in $(seq $((HEAD_A - 100)) $HEAD_A); do + ph=$(curl -sf "http://localhost:3101/block/$((h + 1))" | sed -n 's/.*"phash":"$[^"]*$".*/\1/p') + printf '%s %s\n' "$h" "$ph" >> /tmp/hashes-new_net.txt +done +wc -l /tmp/hashes-new_net.txt # ~101 lines +``` + +Record the per-node version (all four nodes, so the comparison later is exact): + +```bash +for p in 3101 3102 3103 3104; do echo "$p $(curl -s localhost:$p/version)"; done +``` + +Generate pre-migration activity (accounts, transfers, posts, votes, a profile): + +```bash +docker compose run --rm setup node /avalon/scripts/s4-fake-txs.js +``` + +This also creates the balance canaries `s4alice`/`s4bob`/`s4carol` +(balance `20000`), which are checked again after the switch. + +## 4. Phase B — switch to the release candidate + +```bash +cd ../.. +git checkout +cd docker/testnet +docker compose build # only needed if dependencies changed (e.g. sharp) +docker compose -f docker-compose.yml -f docker-compose.migrate.yml up -d \ + --force-recreate --no-deps bootstrap miner1 miner2 miner3 +``` + +`--force-recreate` is required because the running processes still hold the old +code in memory; `--no-deps` keeps the one-shot `setup` service (and mongodb) +from being re-run mid-migration. The overlay applies `s4-patch.js`, which +injects the testnet-only patch: + +- `masterDaoTxs` widened (so the master can fund miners), +- `forceFinalize: true` **at block 100**, so the safety net is active right away + on a fresh testnet instead of at height 13,325,000. + +**This patch is testnet-only and must never be shipped** — the same reason the +runbook warns that the `100: { forceFinalize: true }` entry must not appear in +the released `src/config.js`. + +## 5. Phase C — verify + +Continuity — the chain resumes and extends the same head: + +```bash +count 3101 # must be > $HEAD_A +curl -s "http://localhost:3101/block/$((HEAD_A + 1))" \ + | sed -n 's/.*"phash":"$[^"]*$".*/\1/p' # must equal the hash of $HEAD_A +``` + +Version — identical everywhere, and equal to the release version +(`package.json` → currently `2.0.3`): + +```bash +for p in 3101 3102 3103 3104; do echo "$p $(curl -s localhost:$p/version)"; done +``` + +No economy fork — must print `0`, and stays `0` forever: + +```bash +docker compose logs --no-log-prefix | grep -c "Hard Fork #13330000" +``` + +Force-finalization fork — must appear once the testnet passes block 100: + +```bash +docker compose logs --no-log-prefix | grep "Hard Fork #" | tail -3 +``` + +State preserved and new paths exercised: + +```bash +docker compose run --rm setup node /avalon/scripts/s4-fake-txs.js --post +``` + +This prints a roster with each account's `balance`/`bw`/`keys`, and exercises +the **new** create-account path (which added a bandwidth check). The canaries +`s4alice`/`s4bob`/`s4carol` must still show `balance=20000`. + +## 6. Force-finalization drill + +Two leaders mine a block at the same height. In two terminals, almost +simultaneously (the testnet nodes set `ADMIN_ALLOW_ANONYMOUS=1` in +`docker-compose.yml`, so these token-less `/mineBlock` calls are accepted; a +public node would need `Authorization: Bearer `): + +```bash +curl -s http://localhost:3102/mineBlock # miner1 +curl -s http://localhost:3103/mineBlock # miner2 +``` + +Both blocks land in `possBlocks[]`; no leader reaches 2/3, and after the +backoff the deterministic tie-break (lowest timestamp, then lowest hash) picks +one winner. The chain must keep advancing, with no split: + +```bash +# the head must stay monotonic +for i in $(seq 1 30); do echo "$(date) $(count 3101)"; sleep 2; done + +docker compose logs --no-log-prefix | grep -i "force\|collision" | tail +``` + +## 7. Determinism / re-validation of the historical chain (S4 point 3) + +The validator changes (`validate/json.js`, `float.js`, `integer.js`, +`string.js`, create-account bandwidth, block-size bounds) are **not +height-gated**: they take effect as soon as the new code runs. The requirement +is that the new code still accepts — and re-derives the same hashes for — every +block the old code produced. + +Note the mechanics: a block hash is computed from the block's stored fields +**including its timestamp**, and the timestamp comes from the wall clock +(`chain.prepareBlock()` → `new Date().getTime()`). Two independently mined +chains can therefore never be compared hash-for-hash — the comparison has to be +made on the *same* blocks. So this is a re-validation, not a re-mine. + +Force a node to re-validate the whole history with the new code: drop its local +database and let it sync again from the bootstrap. + +```bash +# each miner has its own database on the shared mongodb service +docker exec avalon-testnet-mongodb mongosh avalon_miner3 --quiet --eval 'db.dropDatabase()' +docker compose -f docker-compose.yml -f docker-compose.migrate.yml up -d \ + --force-recreate --no-deps miner3 +``` + +Let it catch up, then compare its head hash with the bootstrap: + +```bash +until [ "$(count 3104)" -ge "$(count 3101)" ]; do sleep 5; done +H=$(count 3101) +a=$(curl -sf "http://localhost:3101/block/$((H + 1))" | sed -n 's/.*"phash":"$[^"]*$".*/\1/p') +b=$(curl -sf "http://localhost:3104/block/$((H + 1))" | sed -n 's/.*"phash":"$[^"]*$".*/\1/p') +echo "$a"; echo "$b"; [ "$a" = "$b" ] && echo IDENTICAL +``` + +If the new code rejects any historical block, the re-syncing node stalls before +reaching the head — that is the **R2** failure mode, and a mainnet blocker. + +## 8. Teardown / rollback + +```bash +cd docker/testnet +docker compose down -v # remove containers, volumes, testnet keys +git checkout new_net # restore the baseline code state +``` + +## 9. Pitfalls + +- **Run compose from `docker/testnet`.** The bind-mount paths are relative; from + the repository root the mounts resolve to the wrong place. +- **`--force-recreate` is not optional.** Editing `src` on disk does not change a + running node; it must be restarted to load the new code. +- **`setup` and `testnet-genesis.sh` are one-shot.** `testnet-genesis.sh` drops + the database, and `setup` re-creates the miner keys — neither must run during + the migration, hence the overlay and `--no-deps`. +- **The testnet-only patch must not be committed.** `s4-patch.js` edits + `src/config.js` at runtime; if you ever ran it against your working tree, + revert `src/config.js` before committing (check with `git diff src/config.js`). +- **`/count` returns `{"count":N}`**, and a block's own hash is read as the + `phash` of the block above it. + +--- + +*Related*: `docker/testnet/README.md` (testnet setup and the force-finalization +drill), `doc/migration-runbook-no-econs.en.md` §S4 and §S8. diff --git a/doc/v1.5.2-upgrade.md b/doc/v1.5.2-upgrade.md index edc3047..d9d9e09 100644 --- a/doc/v1.5.2-upgrade.md +++ b/doc/v1.5.2-upgrade.md @@ -1,28 +1,30 @@ # Upgrading from <=1.5.1 +> This is a **one-time migration**. Nodes already running v1.5.2 or later do not need it: to update such a node, stop it, run `git pull` and `npm i`, then start it again (see `scripts/start.sh` and [syncing-your-node.md](./syncing-your-node.md)). + From Avalon v1.5.2 onwards, blocks data are appended to and read from a file called `blocks.bson`, which is also the mongo dump file obtained using `mongodump`. This is to take load off the main MongoDB database which results in decreased RAM usage and increased indexing efficiency. To upgrade your node (assuming Avalon is not running): -1. Run a `git pull`. Resolve conflicts for `start.sh` file if required. +1. Run a `git pull`. Resolve conflicts for the `scripts/start.sh` file if required. 2. Install latest node dependencies. ``` npm i ``` -2. Create the dump file for blocks collection. +3. Create the dump file for blocks collection. ``` mongodump -d avalon -c blocks ``` -3. Drop the blocks collection from the mongo database. +4. Drop the blocks collection from the mongo database. ``` mongosh avalon --eval "db.blocks.drop()" ``` -4. Specify the full path to the folder containing the `blocks.bson` file with `BLOCKS_DIR` env var which may also be found in `start.sh` script. -5. Restart `mongod` to realize RAM usage savings. -6. Start Avalon. It should create a file called `blocks.index` which contains the pointers of each block to the `blocks.bson` file (each block takes up exactly 8 bytes of indexing). This may take some time to complete. +5. Specify the full path to the folder containing the `blocks.bson` file with the `BLOCKS_DIR` env var, which may also be found in the `scripts/start.sh` script. +6. Restart `mongod` to realize RAM usage savings. +7. Start Avalon. It should create a file called `blocks.index` which contains the pointers of each block to the `blocks.bson` file (each block takes up exactly 8 bytes of indexing). This may take some time to complete. -The file `blocks.metadata.json` file generated from `mongodump` is not required by Avalon, and can be deleted safely. +The `blocks.metadata.json` file generated from `mongodump` is not required by Avalon in normal operation, and can be deleted safely. Only the full chain rebuild flow (which restores from a `dump/` folder) reads it back. ## Transaction history -Transaction history are now indexed separately with env var `TX_HISTORY`. If `/tx` and `/history` APIs are needed, a full rebuild is required to create the indexes. \ No newline at end of file +Transaction history is indexed separately with the `TX_HISTORY` env var (`TX_HISTORY=1`). If the `/tx` and `/history` APIs are needed, a full rebuild is required to create the indexes. Use `TX_HISTORY_ACCOUNTS` to restrict indexing to a comma-separated list of accounts (transactions where the account is sender, target, receiver, parent author or author); leave it unset to index the whole chain. diff --git a/docker/Dockerfile b/docker/Dockerfile index ba26f73..cb7986f 100644 --- a/docker/Dockerfile +++ b/docker/Dockerfile @@ -24,8 +24,8 @@ RUN apt-get update && apt-get install -y -q --no-install-recommends \ RUN apt-get -y update && apt-get install -y openssl vim tmux locales-all curl -# Install nvm with node and npm -RUN curl -fsSL https://deb.nodesource.com/setup_18.x | bash - && apt-get install -y nodejs +# Install Node.js from NodeSource +RUN curl -fsSL https://deb.nodesource.com/setup_24.x | bash - && apt-get install -y nodejs LABEL "project.home"="https://github.com/dtube/avalon" RUN cd / && git clone https://github.com/dtube/avalon diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml index 6865a2b..6861b97 100644 --- a/docker/docker-compose.yml +++ b/docker/docker-compose.yml @@ -1,4 +1,3 @@ -version: "3.2" services: avalon: build: @@ -29,7 +28,7 @@ services: # ports configuration - HTTP_PORT=${HTTP_PORT} - P2P_PORT=${P2P_PORT} - #- HTTP_HOST=0.0.0.0 + - HTTP_HOST=0.0.0.0 #- P2P_HOST=0.0.0.0 # mongodb configuration - DB_NAME=${DB_NAME} diff --git a/docker/scripts/restartMining.js b/docker/scripts/restartMining.js index 828f54a..b48a1c6 100644 --- a/docker/scripts/restartMining.js +++ b/docker/scripts/restartMining.js @@ -261,7 +261,8 @@ function checkHeightAndRun() { if(createNet) { if (prevbHeight == curbHeight) { - var mineStartCmd = "curl http://localhost:3001/mineBlock" + var adminToken = process.env.ADMIN_TOKEN || process.env.MINE_TOKEN || '' + var mineStartCmd = "curl -fsS -H 'Authorization: Bearer " + adminToken + "' http://localhost:3001/mineBlock" runCmd(mineStartCmd) } } else if (prevbHeight == curbHeight) { diff --git a/docker/test.dockerfile b/docker/test.dockerfile new file mode 100644 index 0000000..799dd44 --- /dev/null +++ b/docker/test.dockerfile @@ -0,0 +1,3 @@ +FROM node:24-alpine +COPY test/force-finalize.js /test/ +CMD ["node", "/test/force-finalize.js"] \ No newline at end of file diff --git a/docker/testnet/Dockerfile b/docker/testnet/Dockerfile new file mode 100644 index 0000000..2330e5d --- /dev/null +++ b/docker/testnet/Dockerfile @@ -0,0 +1,22 @@ +FROM node:24 + +EXPOSE 6001 +EXPOSE 3001 + +WORKDIR /avalon + +RUN apt-get update && apt-get install -y --no-install-recommends curl vim && rm -rf /var/lib/apt/lists/* + +COPY package*.json ./ +RUN npm ci + +COPY src/ src/ +COPY docker/testnet/scripts/ scripts/ + +# Patch masterDaoTxs for testnet so the master (dtube) can transfer/enable/vote +RUN sed -i "s/masterDaoTxs: \[[^]]*\]/masterDaoTxs: [0,1,2,3,4,5,6,7,8,10,11,12,13,14,15,17,18,19,20,21,23,24,25,26,27,28,29,30,32]/" /avalon/src/config.js +# Activate forceFinalize at block 100 for testnet testing +RUN node /avalon/scripts/patch-config.js + +RUN mkdir -p /avalon/log /avalon/genesis /avalon/blocks +RUN chmod +x /avalon/scripts/testnet-*.sh || true diff --git a/docker/testnet/README.md b/docker/testnet/README.md new file mode 100644 index 0000000..abd7c2a --- /dev/null +++ b/docker/testnet/README.md @@ -0,0 +1,92 @@ +# Avalon Testnet — Force Finalization Test + +Testnet multi-nodo per testare il meccanismo di **force finalization** in caso di blocchi concorrenti alla stessa altezza. + +## Requisiti + +- Docker + Docker Compose v2 + +## Avvio + +```bash +cd docker/testnet + +# Build le immagini +docker compose build + +# Avvia tutti i nodi +docker compose up -d + +# Segui i log +docker compose logs -f +``` + +L'avvio automatico: +1. **bootstrap** — crea la rete da zero (genesi, blocco 0, mina i primi blocchi) +2. **setup** — genera 3 chiavi miner, crea gli account, trasferisce token, abilita i nodi, vota i leader +3. **miner1..3** — si sincronizzano con bootstrap e iniziano a minare + +## Architettura + +| Servizio | HTTP (host) | P2P (host) | Account | +|----------|-------------|------------|---------| +| bootstrap | `:3101` | `:6101` | dtube (master) | +| miner1 | `:3102` | `:6102` | miner1 | +| miner2 | `:3103` | `:6103` | miner2 | +| miner3 | `:3104` | `:6104` | miner3 | + +Tutti i nodi sono sulla stessa rete Docker e si scoprono via `PEERS=ws://bootstrap:6001`. + +## Testare la Force Finalization + +### Scenario: blocchi concorrenti + +Per simulare un conflitto (due leader minano blocchi diversi alla stessa altezza): + +```bash +# In due terminali diversi, esegui quasi contemporaneamente: +curl http://localhost:3102/mineBlock # miner1 forza un blocco +curl http://localhost:3103/mineBlock # miner2 forza un blocco +``` + +Se i due `/mineBlock` partono allo stesso micro-intervallo, entrambi i minatori +producono un blocco valido per la stessa altezza N. I nodi della rete li +inseriscono entrambi in `possBlocks[]` e votano. Se nessuno raggiunge 2/3, +dopo ~27 secondi (5 leader × 3s + 2 round × 3s + margine) scatta la +**force finalization**: ogni nodo sceglie deterministicamente il vincitore +(timestamp più basso → hash più basso) e lo finalizza, sbloccando la catena. + +### Verifica + +```bash +# Monitora l'altezza della catena +watch -n 1 'curl -s http://localhost:3101/count' + +# Vedi il log della force finalization +docker compose logs bootstrap | grep -i "force\|collision" + +# Dopo un conflitto, controlla che la catena continui ad avanzare +while true; do + h=$(curl -s http://localhost:3101/count) + echo "Block #$h $(date)" + sleep 2 +done +``` + +### Per fermare tutto + +```bash +docker compose down -v +``` + +## Config + +Le variabili d'ambiente principali sono in `docker-compose.yml`. Le chiavi +generate vengono salvate in un volume condiviso `testnet_config` letto da +tutti i miner. + +Le API admin (`/mineBlock`, `/recover`, `/debug`, `/logs`) sono **fail-closed** +senza token. Per questo il compose di testnet imposta `ADMIN_ALLOW_ANONYMOUS=1` +su bootstrap e miner: così il kickstart di mining e il drill force-finalization +funzionano con i `curl` nudi qui sopra. È un'eccezione **solo locale**: su +mainnet/testernet pubblici va configurato un `ADMIN_TOKEN` reale. diff --git a/docker/testnet/config/.gitkeep b/docker/testnet/config/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/docker/testnet/docker-compose.migrate.yml b/docker/testnet/docker-compose.migrate.yml new file mode 100644 index 0000000..e169e41 --- /dev/null +++ b/docker/testnet/docker-compose.migrate.yml @@ -0,0 +1,6 @@ +# S4 migration phase: restart bootstrap WITHOUT the genesis script +# (testnet-genesis.sh drops the DB on every start — that would destroy chain +# continuity). The config patch is applied idempotently before starting. +services: + bootstrap: + command: ["bash", "-c", "node /avalon/scripts/s4-patch.js && exec node --stack-size=65500 src/main"] diff --git a/docker/testnet/docker-compose.yml b/docker/testnet/docker-compose.yml new file mode 100644 index 0000000..9eecc64 --- /dev/null +++ b/docker/testnet/docker-compose.yml @@ -0,0 +1,183 @@ +services: + mongodb: + image: mongo:6.0.2 + hostname: mongodb + container_name: avalon-testnet-mongodb + ports: + - "37017:27017" + volumes: + - mongo_data:/data/db + healthcheck: + test: echo "db.runCommand({ping:1})" | mongosh --quiet + interval: 5s + timeout: 5s + retries: 15 + + bootstrap: + build: + context: ../.. + dockerfile: docker/testnet/Dockerfile + hostname: bootstrap + container_name: avalon-testnet-bootstrap + ports: + - "3101:3001" + - "6101:6001" + environment: + - HTTP_PORT=3001 + - HTTP_HOST=0.0.0.0 + - P2P_PORT=6001 + - DB_NAME=avalon + - DB_URL=mongodb://mongodb:27017 + - NODE_OWNER=dtube + - NODE_OWNER_PUB=dTuBhkU6SUx9JEx1f4YEt34X9sC7QGso2dSrqE8eJyfz + - NODE_OWNER_PRIV=34EpMEDFJwKbxaF7FhhLyEe3AhpM4dwHMLVfs4JyRto5 + - LOG_LEVEL=cons + - NO_DISCOVERY=1 + - MAX_PEERS=20 + - WARMUP_ACCOUNTS=1000 + - WARMUP_CONTENTS=0 + - ADMIN_ALLOW_ANONYMOUS=1 # testnet only: token-less /mineBlock kickstart + force-finalization drill + volumes: + - ../../src:/avalon/src + - ./scripts:/avalon/scripts:ro + - ../../scripts:/avalon/project-scripts:ro + depends_on: + mongodb: + condition: service_healthy + command: ["bash", "/avalon/scripts/testnet-genesis.sh"] + + setup: + build: + context: ../.. + dockerfile: docker/testnet/Dockerfile + hostname: setup + container_name: avalon-testnet-setup + volumes: + - ../../src:/avalon/src + - ./scripts:/avalon/scripts:ro + - ../../scripts:/avalon/project-scripts:ro + - testnet_config:/avalon/config/testnet-keys + environment: + - HTTP_PORT=3001 + - BOOTSTRAP_HOST=bootstrap + - NODE_OWNER=dtube + - NODE_OWNER_PUB=dTuBhkU6SUx9JEx1f4YEt34X9sC7QGso2dSrqE8eJyfz + - NODE_OWNER_PRIV=34EpMEDFJwKbxaF7FhhLyEe3AhpM4dwHMLVfs4JyRto5 + depends_on: + - bootstrap + command: ["bash", "/avalon/scripts/testnet-setup.sh"] + + miner1: + build: + context: ../.. + dockerfile: docker/testnet/Dockerfile + hostname: miner1 + container_name: avalon-testnet-miner1 + ports: + - "3102:3001" + - "6102:6001" + volumes: + - ../../src:/avalon/src + - ./scripts:/avalon/scripts:ro + - ../../scripts:/avalon/project-scripts:ro + - testnet_config:/avalon/config/testnet-keys + environment: + - HTTP_PORT=3001 + - HTTP_HOST=0.0.0.0 + - P2P_PORT=6001 + - DB_NAME=avalon_miner1 + - DB_URL=mongodb://mongodb:27017 + - NODE_OWNER=miner1 + - NODE_OWNER_PUB= + - NODE_OWNER_PRIV= + - PEERS=ws://bootstrap:6001 + - LOG_LEVEL=cons + - NO_DISCOVERY=1 + - MAX_PEERS=20 + - WARMUP_ACCOUNTS=1000 + - WARMUP_CONTENTS=0 + - ADMIN_ALLOW_ANONYMOUS=1 # testnet only: token-less /mineBlock kickstart + force-finalization drill + depends_on: + mongodb: + condition: service_healthy + setup: + condition: service_started + command: ["bash", "/avalon/scripts/testnet-miner.sh"] + + miner2: + build: + context: ../.. + dockerfile: docker/testnet/Dockerfile + hostname: miner2 + container_name: avalon-testnet-miner2 + ports: + - "3103:3001" + - "6103:6001" + volumes: + - ../../src:/avalon/src + - ./scripts:/avalon/scripts:ro + - ../../scripts:/avalon/project-scripts:ro + - testnet_config:/avalon/config/testnet-keys + environment: + - HTTP_PORT=3001 + - HTTP_HOST=0.0.0.0 + - P2P_PORT=6001 + - DB_NAME=avalon_miner2 + - DB_URL=mongodb://mongodb:27017 + - NODE_OWNER=miner2 + - NODE_OWNER_PUB= + - NODE_OWNER_PRIV= + - PEERS=ws://bootstrap:6001 + - LOG_LEVEL=cons + - NO_DISCOVERY=1 + - MAX_PEERS=20 + - WARMUP_ACCOUNTS=1000 + - WARMUP_CONTENTS=0 + - ADMIN_ALLOW_ANONYMOUS=1 # testnet only: token-less /mineBlock kickstart + force-finalization drill + depends_on: + mongodb: + condition: service_healthy + setup: + condition: service_started + command: ["bash", "/avalon/scripts/testnet-miner.sh"] + + miner3: + build: + context: ../.. + dockerfile: docker/testnet/Dockerfile + hostname: miner3 + container_name: avalon-testnet-miner3 + ports: + - "3104:3001" + - "6104:6001" + volumes: + - ../../src:/avalon/src + - ./scripts:/avalon/scripts:ro + - ../../scripts:/avalon/project-scripts:ro + - testnet_config:/avalon/config/testnet-keys + environment: + - HTTP_PORT=3001 + - HTTP_HOST=0.0.0.0 + - P2P_PORT=6001 + - DB_NAME=avalon_miner3 + - DB_URL=mongodb://mongodb:27017 + - NODE_OWNER=miner3 + - NODE_OWNER_PUB= + - NODE_OWNER_PRIV= + - PEERS=ws://bootstrap:6001 + - LOG_LEVEL=cons + - NO_DISCOVERY=1 + - MAX_PEERS=20 + - WARMUP_ACCOUNTS=1000 + - WARMUP_CONTENTS=0 + - ADMIN_ALLOW_ANONYMOUS=1 # testnet only: token-less /mineBlock kickstart + force-finalization drill + depends_on: + mongodb: + condition: service_healthy + setup: + condition: service_started + command: ["bash", "/avalon/scripts/testnet-miner.sh"] + +volumes: + mongo_data: + testnet_config: diff --git a/docker/testnet/scripts/patch-config.js b/docker/testnet/scripts/patch-config.js new file mode 100644 index 0000000..81f09ab --- /dev/null +++ b/docker/testnet/scripts/patch-config.js @@ -0,0 +1,8 @@ +const fs = require('fs') +let c = fs.readFileSync('/avalon/src/config.js', 'utf8') +c = c.replace( + '241600: {', + '100: {\n forceFinalize: true,\n },\n 241600: {' +) +fs.writeFileSync('/avalon/src/config.js', c) +console.log('Patched forceFinalize activation at block 100') diff --git a/docker/testnet/scripts/s4-fake-txs.js b/docker/testnet/scripts/s4-fake-txs.js new file mode 100644 index 0000000..545ee1a --- /dev/null +++ b/docker/testnet/scripts/s4-fake-txs.js @@ -0,0 +1,168 @@ +// s4-fake-txs.js — realistic fake activity for the S4 migration dry run. +// docker compose run --rm setup node /avalon/scripts/s4-fake-txs.js (pre-migration) +// docker compose run --rm setup node /avalon/scripts/s4-fake-txs.js --post (post-migration) +// User keys are persisted in the testnet_config volume (s4users.json) so the +// same accounts keep acting after the code switch. The pre-migration run also +// creates and funds the passive balance canaries s4alice/s4bob/s4carol +// (balance=20000); they must keep that balance across the migration. +const { execFileSync } = require('child_process') +const { randomBytes } = require('crypto') +const secp256k1 = require('secp256k1') +const bs58 = require('base-x')('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') +const fs = require('fs') + +const API = 'http://' + (process.env.BOOTSTRAP_HOST || 'localhost') + ':' + (process.env.HTTP_PORT || 3001) +const MASTER = process.env.NODE_OWNER || 'dtube' +const MPRIV = process.env.NODE_OWNER_PRIV +const KEYDIR = '/avalon/config/testnet-keys' +const USERS_FILE = KEYDIR + '/s4users.json' +const POST = process.argv.includes('--post') + +function cli(args, priv, name) { + try { + const out = execFileSync('node', ['src/cli.js', ...args, '-A', API, '-K', priv, '-M', name], + { cwd: '/avalon', timeout: 30000, encoding: 'utf8' }).trim() + if (out.startsWith('Error')) { console.log(' -> ' + out); return false } + return true + } catch (e) { console.log(' -> ' + ((e.stdout || '') + ' ' + (e.stderr || '')).trim().slice(0, 300)); return false } +} +function height() { + try { return JSON.parse(execFileSync('curl', ['-sf', API + '/count'], { encoding: 'utf8' })).count } + catch (e) { return 0 } +} +function waitBlocks(n) { + const t = height() + n, dl = Date.now() + 180000 + while (height() < t && Date.now() < dl) execFileSync('sleep', ['1']) +} +function tryTx(label, args, priv, name, attempts) { + for (let i = 0; i < (attempts || 5); i++) { + if (cli(args, priv, name)) { console.log(' ✓', label, '(h=' + height() + ')'); waitBlocks(1); return true } + waitBlocks(2) + } + console.log(' ✗ FAILED', label, '(h=' + height() + ')') + return false +} +function keypair() { + let p + do { p = randomBytes(32) } while (!secp256k1.privateKeyVerify(p)) + return { priv: bs58.encode(p), pub: bs58.encode(secp256k1.publicKeyCreate(p)) } +} +function accountExists(n) { + try { execFileSync('curl', ['-sf', '-o', '/dev/null', API + '/account/' + n], {}); return true } + catch (e) { return false } +} +function envVal(k) { + const m = fs.readFileSync(KEYDIR + '/.env', 'utf8').match(new RegExp('^' + k + '=(\\S+)$', 'm')) + return m && m[1] +} +function loadUsers() { + try { return JSON.parse(fs.readFileSync(USERS_FILE, 'utf8')) } catch (e) { return {} } +} +function saveUsers(u) { fs.writeFileSync(USERS_FILE, JSON.stringify(u, null, 1)) } + +const VIDEO_JSON = JSON.stringify({ + title: 'S4 migration dry-run', + description: 'Fake post produced while rehearsing the no-econs migration on the local testnet.', + video: { ipfs: ['QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG'], provider: 'IPFS' }, + tags: ['dtube', 'testnet'] +}) + +function ensureUsers(users) { + // candidates in order; skip names that exist without a saved key (round-1 orphans) + const candidates = ['s4dave', 's4erin', 's4frank'] + const actors = Object.keys(users).length >= 3 ? Object.keys(users) : [] + for (const c of candidates) { + if (actors.length >= 3) break + if (users[c]) { actors.push(c); continue } + if (accountExists(c)) { console.log(' (skip ' + c + ': exists, key not saved)'); continue } + users[c] = keypair() + if (tryTx('account ' + c, ['account', users[c].pub, c], MPRIV, MASTER)) actors.push(c) + saveUsers(users) + } + return actors.slice(0, 3) +} + +function ensureCanaries() { + // passive balance canaries: keys are throwaway (like the original round-1 + // accounts). Created+funded only in the pre-migration run so criterion #4 + // can check that their balance survives the code switch. + for (const c of ['s4alice', 's4bob', 's4carol']) { + if (accountExists(c)) { console.log(' (canary ' + c + ' already exists)'); continue } + const kp = keypair() + if (tryTx('account ' + c + ' (canary)', ['account', kp.pub, c], MPRIV, MASTER)) + tryTx('transfer 20000 -> ' + c + ' (canary)', ['transfer', c, '20000'], MPRIV, MASTER) + } +} + +async function main() { + console.log('=== S4 fake txs ===', POST ? '(post-migration mode)' : '(pre-migration mode)', 'API:', API, 'h=' + height()) + const users = loadUsers() + const miner1 = envVal('MINER1_PRIV'), miner2 = envVal('MINER2_PRIV') + + if (!POST) { + console.log('--- balance canaries (s4alice/s4bob/s4carol, 20000 each) ---') + ensureCanaries() + + console.log('--- ensuring actor accounts (master) ---') + const actors = ensureUsers(users) // [a, b, c] + const [a, b, c] = actors + if (!a) { console.log('FATAL: no actors'); process.exit(1) } + + console.log('--- grants: 1,000,000 each (bwGrowth is +10 bytes/h per DTC) ---') + for (const n of actors) + tryTx('transfer 1000000 -> ' + n, ['transfer', n, '1000000'], MPRIV, MASTER) + console.log('--- waiting 20 blocks for bandwidth to accumulate ---') + waitBlocks(20) + + console.log('--- posts / reply ---') + tryTx('master post s4-main-post', ['comment', 's4-main-post', '', '', VIDEO_JSON, '5', 'dtube'], MPRIV, MASTER) + tryTx(a + ' post s4-' + a.replace('s4', '') + '-post', ['comment', 's4-' + a.slice(2) + '-post', '', '', VIDEO_JSON, '1', 'dtube'], users[a].priv, a) + tryTx(b + ' reply', ['comment', 's4-reply-' + b.slice(2), a, 's4-' + a.slice(2) + '-post', JSON.stringify({ body: 'Nice first post, ' + a + '!' }), '1', 'dtube'], users[b].priv, b) + + console.log('--- votes ---') + tryTx(c + ' votes master post', ['vote', 's4-main-post', 'dtube', '2', 'dtube'], users[c].priv, c) + if (miner2) tryTx('miner2 votes ' + a + ' post', ['vote', 's4-' + a.slice(2) + '-post', a, '1', 'dtube'], miner2, 'miner2') + if (miner1) tryTx('miner1 tipped-vote master post', ['tipped-vote', 's4-main-post', 'dtube', '1', 'dtube', '10'], miner1, 'miner1') + + console.log('--- user transfer + profile ---') + tryTx(a + ' -> ' + b + ' 123', ['transfer', b, '123'], users[a].priv, a) + tryTx(a + ' profile', ['profile', JSON.stringify({ about: 's4 test user', pic: 'https://example.com/pic.png' })], users[a].priv, a) + + console.log('--- negative test: commentEdit must be rejected (txLimits 23/24) ---') + tryTx('master comment-edit (expected disabled)', ['comment-edit', 's4-main-post', '{"title":"edited"}'], MPRIV, MASTER, 1) + } else { + const actors = Object.keys(loadUsers()) + const [a, b, c] = actors + console.log('--- post-migration activity (new validators live) ---') + ensureUsers(users) // may add a 4th user via the NEW create-account path + const u2 = loadUsers() + const [x, y] = Object.keys(u2).slice(-2) + + // exercise the NEW create-account path (hardening added a bandwidth check) + if (!u2.s4gina && !accountExists('s4gina')) { + const kp = keypair() + if (tryTx('account s4gina (new-code create-account path)', ['account', kp.pub, 's4gina'], MPRIV, MASTER)) { + u2.s4gina = kp; saveUsers(u2) + tryTx('transfer 100000 -> s4gina', ['transfer', 's4gina', '100000'], MPRIV, MASTER) + } + } + + tryTx('master post s4-post-migration', ['comment', 's4-post-migration', '', '', VIDEO_JSON, '3', 'dtube'], MPRIV, MASTER) + tryTx(x + ' votes it', ['vote', 's4-post-migration', 'dtube', '1', 'dtube'], u2[x].priv, x) + if (a && b) tryTx(a + ' -> ' + b + ' 50', ['transfer', b, '50'], u2[a] ? u2[a].priv : null, a) + if (a) tryTx(a + ' profile edit', ['profile', JSON.stringify({ about: 's4 test user (post-migration)', pic: 'https://example.com/pic.png' })], u2[a].priv, a) + console.log('--- negative test parity: commentEdit still disabled under new code ---') + tryTx('master comment-edit (expected disabled)', ['comment-edit', 's4-main-post', '{"title":"edited"}'], MPRIV, MASTER, 1) + } + + console.log('--- final state ---') + const roster = [MASTER, 'miner1', 'miner2', 's4alice', 's4bob', 's4carol', ...Object.keys(loadUsers())] + for (const n of [...new Set(roster)]) { + try { + const a = JSON.parse(execFileSync('curl', ['-sf', API + '/account/' + n], { encoding: 'utf8' })) + console.log(' ' + n + ': balance=' + a.balance + ' bw=' + JSON.stringify(a.bw) + ' keys=' + (a.keys || []).length) + } catch (e) { console.log(' ' + n + ': ') } + } + console.log('=== done, height ' + height() + ' ===') +} +main().catch(e => { console.error('FATAL:', e); process.exit(1) }) diff --git a/docker/testnet/scripts/s4-patch.js b/docker/testnet/scripts/s4-patch.js new file mode 100644 index 0000000..3f87790 --- /dev/null +++ b/docker/testnet/scripts/s4-patch.js @@ -0,0 +1,12 @@ +// s4-patch.js — idempotent testnet config patch (same effect as the inline +// patches in testnet-genesis.sh / testnet-miner.sh): masterDaoTxs for the +// master account + forceFinalize activation at block 100. +const fs = require('fs') +const p = '/avalon/src/config.js' +let c = fs.readFileSync(p, 'utf8') +const before = c +c = c.replace(/masterDaoTxs: \[[^\]]*\]/, 'masterDaoTxs: [0,1,2,3,4,5,6,7,8,10,11,12,13,14,15,17,18,19,20,21,23,24,25,26,27,28,29,30,32]') +if (!c.includes('100: {\n forceFinalize: true')) + c = c.replace('241600: {', '100: {\n forceFinalize: true,\n },\n 241600: {') +fs.writeFileSync(p, c) +console.log(c === before ? 'Config already patched' : 'Patched testnet config (masterDaoTxs + forceFinalize@100)') diff --git a/docker/testnet/scripts/setup-testnet.js b/docker/testnet/scripts/setup-testnet.js new file mode 100644 index 0000000..0a54776 --- /dev/null +++ b/docker/testnet/scripts/setup-testnet.js @@ -0,0 +1,154 @@ +// setup-testnet.js - Generates miner keys and initializes testnet accounts +const { randomBytes } = require('crypto') +const secp256k1 = require('secp256k1') +const bs58 = require('base-x')('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') +const fs = require('fs') +const { execSync } = require('child_process') + +const MINERS = 3 +const API = 'http://' + (process.env.BOOTSTRAP_HOST || 'localhost') + ':' + (process.env.HTTP_PORT || 3001) +const MASTER = process.env.NODE_OWNER || 'dtube' +const PRIV = process.env.NODE_OWNER_PRIV + +function run(cmd) { + try { + return execSync(cmd, { cwd: '/avalon', timeout: 60000 }).toString().trim() + } catch (e) { + const err = e.stderr ? e.stderr.toString().trim() : e.message + const redacted = cmd.replace(/-K\s+\S+/g, '-K [REDACTED]') + console.error('FAILED:', redacted, err) + return null + } +} + +function cli(args, signKey, signName) { + signKey = signKey || PRIV + signName = signName || MASTER + const out = run(`node src/cli.js ${args} -A ${API} -K ${signKey} -M ${signName}`) + if (out && out.startsWith('Error:')) return null + return out +} + +function genKeypair() { + let priv, pub + do { + priv = randomBytes(32) + } while (!secp256k1.privateKeyVerify(priv)) + pub = secp256k1.publicKeyCreate(priv) + return { priv: bs58.encode(priv), pub: bs58.encode(pub) } +} + +function getBlockCount() { + const raw = run(`curl -sf ${API}/count 2>/dev/null || echo '{"count":0}'`) + try { + return parseInt(JSON.parse(raw).count) || 0 + } catch (e) { + return 0 + } +} + +function waitBlocks(n) { + const target = getBlockCount() + n + const deadline = Date.now() + 120000 + while (Date.now() < deadline) { + const h = getBlockCount() + if (h >= target) return + execSync('sleep 2') + } + console.error('TIMEOUT: waited 120s for ' + n + ' block(s), giving up') +} + +async function main() { + console.log('\n=== Testnet Setup ===') + console.log('API:', API, 'Master:', MASTER) + + const cfgDir = '/avalon/config/testnet-keys' + fs.mkdirSync(cfgDir, { recursive: true }) + + const miners = [] + + for (let i = 1; i <= MINERS; i++) { + const name = `miner${i}` + const ws = `ws://${name}:6001` + const kp = genKeypair() + miners.push({ name, ...kp, ws }) + console.log(`\n ${name}: pub=${kp.pub.slice(0, 16)}... priv=${kp.priv.slice(0, 8)}...`) + } + + console.log('\n--- Creating accounts ---') + for (const m of miners) { + for (let attempt = 0; attempt < 30; attempt++) { + const r = cli(`account ${m.pub} ${m.name}`) + if (r) { + console.log(` ✓ ${m.name} created`) + // write config early so miner container can start syncing ASAP + fs.writeFileSync(`${cfgDir}/${m.name}.json`, JSON.stringify(m, null, 2)) + break + } + console.log(` retry ${m.name} (block ${attempt})...`) + waitBlocks(1) + } + } + + console.log('\n--- Transferring tokens ---') + waitBlocks(3) + for (const m of miners) { + for (let attempt = 0; attempt < 30; attempt++) { + const r = cli(`transfer ${m.name} 100000`) + if (r) { + console.log(` ✓ ${m.name} transfer`) + break + } + console.log(` retry ${m.name} transfer (block ${attempt})...`) + waitBlocks(1) + } + } + + console.log('\n--- Enabling nodes (waiting for bandwidth to grow) ---') + waitBlocks(40) + for (const m of miners) { + for (let attempt = 0; attempt < 60; attempt++) { + const r = cli(`enable-node ${m.pub}`, m.priv, m.name) + if (r) { + console.log(` ✓ ${m.name} enabled`) + fs.writeFileSync(`${cfgDir}/${m.name}.json`, JSON.stringify(m, null, 2)) + break + } + console.log(` retry ${m.name} enable-node (block ${attempt})...`) + waitBlocks(3) + } + } + + console.log('\n--- Waiting for miners to connect (configs written, miners should start soon) ---') + waitBlocks(5) + console.log('--- Connectivity check ---') + run(`curl -sf ${API}/peers 2>/dev/null || echo "no peers yet"`) + + console.log('\n--- Voting for leaders ---') + for (const m of miners) { + for (let attempt = 0; attempt < 30; attempt++) { + const r = cli(`vote-leader ${m.name}`) + if (r) { + console.log(` ✓ ${m.name} voted`) + break + } + console.log(` retry ${m.name} vote-leader (block ${attempt})...`) + waitBlocks(1) + } + } + + // Write consolidated env + const env = miners.map(m => + `${m.name.toUpperCase()}_PUB=${m.pub}\n${m.name.toUpperCase()}_PRIV=${m.priv}` + ).join('\n') + fs.writeFileSync(`${cfgDir}/.env`, env) + + console.log('\n=== Setup Complete ===') + console.log('Keys written to', cfgDir) + miners.forEach(m => console.log(` ${m.name}: PUB=${m.pub} PRIV=${m.priv}`)) +} + +main().catch(e => { + console.error('FATAL:', e) + process.exit(1) +}) diff --git a/docker/testnet/scripts/testnet-genesis.sh b/docker/testnet/scripts/testnet-genesis.sh new file mode 100644 index 0000000..6d591cc --- /dev/null +++ b/docker/testnet/scripts/testnet-genesis.sh @@ -0,0 +1,60 @@ +#!/bin/bash +# genesis.sh - Bootstrap node entrypoint for testnet +set -euo pipefail + +echo "=== Avalon Testnet - Bootstrap Node ===" + +DB_URL="${DB_URL:-mongodb://mongodb:27017}" +DB_NAME="${DB_NAME:-avalon}" + +# Fresh testnet: drop stale data +cd /avalon +node -e " +const MongoClient = require('mongodb').MongoClient; +MongoClient.connect('${DB_URL}', {useNewUrlParser:true, useUnifiedTopology:true}, (e,c) => { + if (e) { console.log('MongoDB connection:', e.message); process.exit(0); } + c.db('${DB_NAME}').dropDatabase().then(() => { console.log('Dropped ${DB_NAME}'); c.close(); process.exit(0); }); +}); +" 2>&1 || true + +rm -rf /avalon/genesis/* /avalon/blocks/* 2>/dev/null || true + +# Patch config for testnet (replaces Dockerfile sed/patch-config that are lost when src is bind-mounted) +node -e " +const fs = require('fs'); +let c = fs.readFileSync('/avalon/src/config.js', 'utf8'); +c = c.replace(/masterDaoTxs: \[[^\]]*\]/, 'masterDaoTxs: [0,1,2,3,4,5,6,7,8,10,11,12,13,14,15,17,18,19,20,21,23,24,25,26,27,28,29,30,32]'); +if (!c.includes('100:')) + c = c.replace('241600: {', '100: {\\n forceFinalize: true,\\n },\\n 241600: {'); +fs.writeFileSync('/avalon/src/config.js', c); +console.log('Patched config for testnet'); +" + +echo "Starting Avalon node..." +node --stack-size=65500 src/main & +AVALON_PID=$! + +# Wait for API +echo "Waiting for API..." +for i in $(seq 1 30); do + if curl -sf "http://localhost:3001/count" &>/dev/null; then + echo "API ready" + break + fi + sleep 2 +done + +# Kickstart mining: call /mineBlock until blocks start flowing +echo "Kickstarting block production..." +for i in $(seq 1 20); do + sleep 3 + HEIGHT=$(curl -sf "http://localhost:3001/count" 2>/dev/null | grep -oP '"count":\K\d+' || echo "0") + echo "Block height: $HEIGHT" + if [ "$HEIGHT" -ge 5 ] 2>/dev/null; then + echo "Chain is producing blocks autonomously" + break + fi + curl -sf "http://localhost:3001/mineBlock" -o /dev/null 2>/dev/null || true +done + +wait $AVALON_PID diff --git a/docker/testnet/scripts/testnet-miner.sh b/docker/testnet/scripts/testnet-miner.sh new file mode 100644 index 0000000..4f19e06 --- /dev/null +++ b/docker/testnet/scripts/testnet-miner.sh @@ -0,0 +1,41 @@ +#!/bin/bash +# miner.sh - Leader node entrypoint for testnet +set -euo pipefail + +MINER_NAME="${NODE_OWNER}" +echo "=== Avalon Testnet - Miner: ${MINER_NAME} ===" + +# Wait for config file from setup container +CONFIG_FILE="/avalon/config/testnet-keys/${MINER_NAME}.json" +echo "Waiting for config at $CONFIG_FILE..." +for i in $(seq 1 600); do + if [ -f "$CONFIG_FILE" ]; then + echo "Config found" + export NODE_OWNER_PUB=$(node -e "console.log(require('$CONFIG_FILE').pub)") + export NODE_OWNER_PRIV=$(node -e "console.log(require('$CONFIG_FILE').priv)") + echo "Pub: ${NODE_OWNER_PUB:0:16}... Priv: ${NODE_OWNER_PRIV:0:8}..." + break + fi + sleep 2 +done + +if [ -z "${NODE_OWNER_PUB:-}" ]; then + echo "ERROR: No config found for ${MINER_NAME} at ${CONFIG_FILE}" + exit 1 +fi + +rm -rf /avalon/blocks/* 2>/dev/null || true + +# Patch config for testnet (matches genesis.sh — ensures consistent config across nodes) +node -e " +const fs = require('fs'); +let c = fs.readFileSync('/avalon/src/config.js', 'utf8'); +c = c.replace(/masterDaoTxs: \[[^\]]*\]/, 'masterDaoTxs: [0,1,2,3,4,5,6,7,8,10,11,12,13,14,15,17,18,19,20,21,23,24,25,26,27,28,29,30,32]'); +if (!c.includes('100:')) + c = c.replace('241600: {', '100: {\\n forceFinalize: true,\\n },\\n 241600: {'); +fs.writeFileSync('/avalon/src/config.js', c); +" + +echo "Starting Avalon node..." +cd /avalon +exec node --stack-size=65500 src/main diff --git a/docker/testnet/scripts/testnet-setup.sh b/docker/testnet/scripts/testnet-setup.sh new file mode 100644 index 0000000..c6dbafe --- /dev/null +++ b/docker/testnet/scripts/testnet-setup.sh @@ -0,0 +1,41 @@ +#!/bin/bash +# setup.sh - Initializes testnet miner accounts +set -euo pipefail + +echo "=== Avalon Testnet - Setup ===" + +BOOTSTRAP="${BOOTSTRAP_HOST:-bootstrap}" +API="http://${BOOTSTRAP}:${HTTP_PORT:-3001}" + +# Wait for bootstrap node to be ready +echo "Waiting for bootstrap API at $API..." +for i in $(seq 1 60); do + COUNT=$(curl -sf "$API/count" 2>/dev/null | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.parse(d).count))" 2>/dev/null || echo "") + if [ -n "$COUNT" ] && [ "$COUNT" != "null" ]; then + echo "Bootstrap ready at block #$COUNT" + break + fi + sleep 2 +done + +# Wait for a few blocks so we can create accounts +echo "Waiting for blocks to accumulate..." +DEADLINE=$(( $(date +%s) + 120 )) +while [ $(date +%s) -lt $DEADLINE ]; do + COUNT=$(curl -sf "$API/count" 2>/dev/null | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.parse(d).count))" 2>/dev/null || echo "0") + if [ "$COUNT" -ge 5 ] 2>/dev/null; then + echo "Enough blocks mined ($COUNT), starting account creation" + break + fi + sleep 3 +done +if [ "$COUNT" -lt 5 ] 2>/dev/null; then + echo "TIMEOUT: waited 120s for 5 blocks, check chain health" + exit 1 +fi + +# Run the setup script using the bootstrap's CLI (need node + src) +cd /avalon +node /avalon/scripts/setup-testnet.js + +echo "=== Setup Complete ===" diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..bc47e5f --- /dev/null +++ b/package-lock.json @@ -0,0 +1,8476 @@ +{ + "name": "avalon", + "version": "2.0.3", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "avalon", + "version": "2.0.3", + "dependencies": { + "base-x": "^3.0.11", + "body-parser": "^1.20.5", + "bson": "^4.7.2", + "clone-deep": "^4.0.1", + "commander": "^2.20.3", + "cors": "^2.8.6", + "decay": "^1.0.12", + "esbuild-loader": "^4.5.0", + "express": "^4.22.2", + "express-rate-limit": "^8.5.2", + "growint": "^1.0.1", + "javalon2": "^1.1.10", + "log4js": "^6.9.1", + "mongodb": "^4.17.2", + "node-fetch-commonjs": "^3.3.2", + "oembed-parser": "^1.5.2", + "open-graph-scraper": "^4.11.1", + "run-parallel": "^1.2.0", + "run-series": "^1.1.9", + "secp256k1": "^4.0.4", + "sha256-file": "^1.0.0", + "sharp": "^0.35.5", + "signale": "^1.4.0", + "simple-youtube-api": "^5.2.1", + "ws": "^7.5.11" + }, + "devDependencies": { + "apidoc": "^1.2.0", + "chance": "^1.1.13", + "eslint": "^8.57.1" + }, + "engines": { + "node": ">=24.0.0" + } + }, + "node_modules/@aws-crypto/sha256-browser": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/@aws-crypto/sha256-browser/-/sha256-browser-5.2.0.tgz", + "integrity": "sha512-AXfN/lGotSQwu6HNcEsIASo7kWXZ5HYWvfOmSNKDsEqC4OashTp8alTmaz+F7TC2L083SFv5RdB+qU3Vs1kZqw==", + "license": "Apache-2.0", + "dependencies": { + "@aws-crypto/sha256-js": "^5.2.0", + "@aws-crypto/supports-web-crypto": "^5.2.0", + "@aws-crypto/util": "^5.2.0", + "@aws-sdk/types": "^3.222.0", + "@aws-sdk/util-locate-window": "^3.0.0", + "@smithy/util-utf8": "^2.0.0", + "tslib": "^2.6.2" + } + }, + "node_modules/@aws-crypto/sha256-js": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/@aws-crypto/sha256-js/-/sha256-js-5.2.0.tgz", + "integrity": "sha512-FFQQyu7edu4ufvIZ+OadFpHHOt+eSTBaYaki44c+akjg7qZg9oOQeLlk77F6tSYqjDAFClrHJk9tMf0HdVyOvA==", + "license": "Apache-2.0", + "dependencies": { + "@aws-crypto/util": "^5.2.0", + "@aws-sdk/types": "^3.222.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=16.0.0" + } + }, + "node_modules/@aws-crypto/supports-web-crypto": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/@aws-crypto/supports-web-crypto/-/supports-web-crypto-5.2.0.tgz", + "integrity": "sha512-iAvUotm021kM33eCdNfwIN//F77/IADDSs58i+MDaOqFrVjZo9bAal0NK7HurRuWLLpF1iLX7gbWrjHjeo+YFg==", + "license": "Apache-2.0", + "dependencies": { + "tslib": "^2.6.2" + } + }, + "node_modules/@aws-crypto/util": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/@aws-crypto/util/-/util-5.2.0.tgz", + "integrity": "sha512-4RkU9EsI6ZpBve5fseQlGNUWKMa1RLPQ1dnjnQoe07ldfIzcsGb5hC5W0Dm7u423KWzawlrpbjXBrXCEv9zazQ==", + "license": "Apache-2.0", + "dependencies": { + "@aws-sdk/types": "^3.222.0", + "@smithy/util-utf8": "^2.0.0", + "tslib": "^2.6.2" + } + }, + "node_modules/@aws-sdk/core": { + "version": "3.978.7", + "resolved": "https://registry.npmjs.org/@aws-sdk/core/-/core-3.978.7.tgz", + "integrity": "sha512-QsYdn5xhvEBzcDC6bgKuvPv87kFtXK/3f5NqKfR+eok5AAn7RaZnkgBKncX+UW3ZMcjSELyAMATN0iqgZmvWVg==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@aws-sdk/types": "^3.975.0", + "@aws-sdk/xml-builder": "^3.972.42", + "@aws/lambda-invoke-store": "^0.3.0", + "@smithy/core": "^3.37.0", + "@smithy/signature-v4": "^5.7.4", + "@smithy/types": "^4.19.0", + "bowser": "^2.11.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/credential-provider-cognito-identity": { + "version": "3.972.77", + "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-cognito-identity/-/credential-provider-cognito-identity-3.972.77.tgz", + "integrity": "sha512-1zAeDo8u8lQBCfpmbi9WXG9uLCA31yUcvv4FhWjFv+2Q9AvLdA6PyNyzGmLbPNPH5Af09bF8xUUK/FrHmmHYdg==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@aws-sdk/nested-clients": "^3.997.52", + "@aws-sdk/types": "^3.975.0", + "@smithy/core": "^3.37.0", + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/credential-provider-env": { + "version": "3.972.78", + "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-env/-/credential-provider-env-3.972.78.tgz", + "integrity": "sha512-d8V47OxkM/FKe7bVfk5Rga4aNGUaQNk3ip1PFIYhxtup9r8SuNIHLs4HfBAmHT25ZbzowluMHp833UXfFMQbhA==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@aws-sdk/core": "^3.978.7", + "@aws-sdk/types": "^3.975.0", + "@smithy/core": "^3.37.0", + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/credential-provider-http": { + "version": "3.972.80", + "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-http/-/credential-provider-http-3.972.80.tgz", + "integrity": "sha512-OQqanXiRhnl/wBIJc3TtA7TYmnN7VO0mP95eVoHsLXtPwHz6HeccMpi7cqtnhHw+K7p6VIoAt2IK4M9Ixd9uGg==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@aws-sdk/core": "^3.978.7", + "@aws-sdk/types": "^3.975.0", + "@smithy/core": "^3.37.0", + "@smithy/fetch-http-handler": "^5.8.0", + "@smithy/node-http-handler": "^4.13.0", + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/credential-provider-ini": { + "version": "3.973.23", + "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-ini/-/credential-provider-ini-3.973.23.tgz", + "integrity": "sha512-pTTRK7xoi8NNbrcjVUSd9YdMTUxiWEPfk8newBQCzV+VS5STh5sDPAy3iO29fSqipqNuCpILJcD6wAawxHvG+w==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@aws-sdk/core": "^3.978.7", + "@aws-sdk/credential-provider-env": "^3.972.78", + "@aws-sdk/credential-provider-http": "^3.972.80", + "@aws-sdk/credential-provider-login": "^3.972.85", + "@aws-sdk/credential-provider-process": "^3.972.78", + "@aws-sdk/credential-provider-sso": "^3.973.22", + "@aws-sdk/credential-provider-web-identity": "^3.972.84", + "@aws-sdk/nested-clients": "^3.997.52", + "@aws-sdk/types": "^3.975.0", + "@smithy/core": "^3.37.0", + "@smithy/credential-provider-imds": "^4.5.2", + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/credential-provider-login": { + "version": "3.972.85", + "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-login/-/credential-provider-login-3.972.85.tgz", + "integrity": "sha512-UHjnTeS+5OBFfRL+BQwCGJPJvnzjhGD6dIwncBJDa+ziyQjPUte9Q0I4BCkybGrHotnyiiluXj13bgelP14J5Q==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@aws-sdk/core": "^3.978.7", + "@aws-sdk/nested-clients": "^3.997.52", + "@aws-sdk/types": "^3.975.0", + "@smithy/core": "^3.37.0", + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/credential-provider-node": { + "version": "3.972.90", + "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-node/-/credential-provider-node-3.972.90.tgz", + "integrity": "sha512-+McgOQuAUze95AumVmoOBRp++Z8IjsZ0qOASb6+igHdKNzA0FiIf5kbTFaZ64txfd9KTBDpgvlEDGQE41lSq/A==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@aws-sdk/credential-provider-env": "^3.972.78", + "@aws-sdk/credential-provider-http": "^3.972.80", + "@aws-sdk/credential-provider-ini": "^3.973.23", + "@aws-sdk/credential-provider-process": "^3.972.78", + "@aws-sdk/credential-provider-sso": "^3.973.22", + "@aws-sdk/credential-provider-web-identity": "^3.972.84", + "@aws-sdk/types": "^3.975.0", + "@smithy/core": "^3.37.0", + "@smithy/credential-provider-imds": "^4.5.2", + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/credential-provider-process": { + "version": "3.972.78", + "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-process/-/credential-provider-process-3.972.78.tgz", + "integrity": "sha512-bzB92SriflYf6LVRJcDv/a9I87tmkdmdE8hAqT1oRGKFkEH2rxxHeHZVK/4vsiRsFi44cUj0J9+bUSmqYX+26w==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@aws-sdk/core": "^3.978.7", + "@aws-sdk/types": "^3.975.0", + "@smithy/core": "^3.37.0", + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/credential-provider-sso": { + "version": "3.973.22", + "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-sso/-/credential-provider-sso-3.973.22.tgz", + "integrity": "sha512-MXUkWHgcf6G+TowL+QPvn4kJTEYKd9qHKMV6eNGXSA5lilDgGRrP3EXPHChZ3eZ7z+oprn/ZvOovLoS2WR3D8g==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@aws-sdk/core": "^3.978.7", + "@aws-sdk/nested-clients": "^3.997.52", + "@aws-sdk/token-providers": "3.1159.0", + "@aws-sdk/types": "^3.975.0", + "@smithy/core": "^3.37.0", + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/credential-provider-web-identity": { + "version": "3.972.84", + "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-web-identity/-/credential-provider-web-identity-3.972.84.tgz", + "integrity": "sha512-6I3zYcDHt5ZM0J4gEuRgCHgN505k5haUiiPM46iIQgrHm2p70zpnssHFVYqHYfgJe3Mf+a5+nsF3BZmW4xcZNg==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@aws-sdk/core": "^3.978.7", + "@aws-sdk/nested-clients": "^3.997.52", + "@aws-sdk/types": "^3.975.0", + "@smithy/core": "^3.37.0", + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/credential-providers": { + "version": "3.1159.0", + "resolved": "https://registry.npmjs.org/@aws-sdk/credential-providers/-/credential-providers-3.1159.0.tgz", + "integrity": "sha512-Rr/yasmXA/k+1CdWCikE9D9vex72QaCYABf8Mun5dXE8fjbGX3x+/ii9SM9m8K8accgwSOJUmFYT7+zfzfK5bg==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@aws-sdk/core": "^3.978.7", + "@aws-sdk/credential-provider-cognito-identity": "^3.972.77", + "@aws-sdk/credential-provider-env": "^3.972.78", + "@aws-sdk/credential-provider-http": "^3.972.80", + "@aws-sdk/credential-provider-ini": "^3.973.23", + "@aws-sdk/credential-provider-login": "^3.972.85", + "@aws-sdk/credential-provider-node": "^3.972.90", + "@aws-sdk/credential-provider-process": "^3.972.78", + "@aws-sdk/credential-provider-sso": "^3.973.22", + "@aws-sdk/credential-provider-web-identity": "^3.972.84", + "@aws-sdk/nested-clients": "^3.997.52", + "@aws-sdk/types": "^3.975.0", + "@smithy/core": "^3.37.0", + "@smithy/credential-provider-imds": "^4.5.2", + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/nested-clients": { + "version": "3.997.52", + "resolved": "https://registry.npmjs.org/@aws-sdk/nested-clients/-/nested-clients-3.997.52.tgz", + "integrity": "sha512-/bNl6b3VEoWQg3Z8yHt3gzYjSFoOOv7+eUglzITmGP8H7jovN8c9NoOI+6bU25+lSLvyRpJOs4n8YSaX+BcUPg==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@aws-sdk/core": "^3.978.7", + "@aws-sdk/signature-v4-multi-region": "^3.996.50", + "@aws-sdk/types": "^3.975.0", + "@smithy/core": "^3.37.0", + "@smithy/fetch-http-handler": "^5.8.0", + "@smithy/node-http-handler": "^4.13.0", + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/signature-v4-multi-region": { + "version": "3.996.50", + "resolved": "https://registry.npmjs.org/@aws-sdk/signature-v4-multi-region/-/signature-v4-multi-region-3.996.50.tgz", + "integrity": "sha512-Ob9GCZ3YnGPws696zTYW/rLFYHa9QLh6DgTCnkHb+0jhHNBgHWM8Ui2b+yrIjkfDsRVsglyrOey6tOOG/VWxMA==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@aws-sdk/types": "^3.975.0", + "@smithy/signature-v4": "^5.7.4", + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/token-providers": { + "version": "3.1159.0", + "resolved": "https://registry.npmjs.org/@aws-sdk/token-providers/-/token-providers-3.1159.0.tgz", + "integrity": "sha512-IJvghXXcEpqTWGjrjJwxBdEecHeXp+t9FaybRf8Zf0wYW84KN1snXBsYOdfDBBx78ChwfJxH8KIHqmhNZuDLcw==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@aws-sdk/core": "^3.978.7", + "@aws-sdk/nested-clients": "^3.997.52", + "@aws-sdk/types": "^3.975.0", + "@smithy/core": "^3.37.0", + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/types": { + "version": "3.975.0", + "resolved": "https://registry.npmjs.org/@aws-sdk/types/-/types-3.975.0.tgz", + "integrity": "sha512-WQlhs6juByzWOzj5fwxOx0mPJaEqMcG/sDpl3Id61B3XhKE63xY+0QWcnG+sWR/sCfprmreyUo1lM7IKZmHMzw==", + "license": "Apache-2.0", + "dependencies": { + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/util-locate-window": { + "version": "3.965.10", + "resolved": "https://registry.npmjs.org/@aws-sdk/util-locate-window/-/util-locate-window-3.965.10.tgz", + "integrity": "sha512-ycwH6Zd2GhuSqdXX9ihbCjeGTB6xOJs+O3+Jb8/zDG9978XU80qs75dfkPJRMNKe5MvBZPuNeFpd4JZKPoUF4g==", + "license": "Apache-2.0", + "dependencies": { + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws-sdk/xml-builder": { + "version": "3.972.42", + "resolved": "https://registry.npmjs.org/@aws-sdk/xml-builder/-/xml-builder-3.972.42.tgz", + "integrity": "sha512-smX8/gNP8Kjq+CWTBMZQLQ912vOQjiWExzwzvMO+eujPB5RY8IbtF0AGdUUXHKN7KoDWK9dIcuW0WG269kiP6w==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@aws/lambda-invoke-store": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/@aws/lambda-invoke-store/-/lambda-invoke-store-0.3.0.tgz", + "integrity": "sha512-sl4Bm6yiMNYrZKkqqDFWN0UfnWhlS8ivKxrYl+6t0gCLrqr8y3B2IqZZbFRkfaVVp7C/baApyh71P+LeE1A2sQ==", + "license": "Apache-2.0", + "optional": true, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/@colors/colors": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.6.1.tgz", + "integrity": "sha512-dTmUJzXSuayBK+hZydEaXd2mhx61qWQwkwaBBY6LyEOVx/L9aQU5ac8eFNEsd9nrD1+zb9zvDCphLSe8g1F4Qw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.1.90" + } + }, + "node_modules/@dabh/diagnostics": { + "version": "2.0.9", + "resolved": "https://registry.npmjs.org/@dabh/diagnostics/-/diagnostics-2.0.9.tgz", + "integrity": "sha512-R6siwR65Hm+3yfgP7o8DKhNvputQAwfoz9zTc3kyDudnomj2/BcLmD+uGQQPICjuFUp8ounPBU+jmKsocwVVAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@so-ric/colorspace": "^1.1.6", + "enabled": "2.0.x", + "kuler": "^2.0.0" + } + }, + "node_modules/@discoveryjs/json-ext": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz", + "integrity": "sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/@emnapi/runtime": { + "version": "1.11.3", + "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.3.tgz", + "integrity": "sha512-Xz4Tpyki7XyrpbUK1jR1AhdAdaXyhhY4lZ3neLodmhpuWfy2PAQN5B46sAiU4liOXGLkHypn/qU+jvfWSCYYLA==", + "license": "MIT", + "optional": true, + "dependencies": { + "tslib": "^2.4.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.2.tgz", + "integrity": "sha512-XExcO+dvLKvVtNTibSTBej1NCAbaGhWn9Ww1ZPx80qsahhPFe/8jgWP0IchNe0F3HwkU7n8ejhH8bjonqht8mQ==", + "cpu": [ + "ppc64" + ], + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.2.tgz", + "integrity": "sha512-kXXoiPVVGQcnIYGOeaovwOURpniDBpSq4A03qkQ+BMQqtGG6HYap3xne9C1O1yo4TR3qxlCX5IqqmX6fFo2Lqg==", + "cpu": [ + "arm" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.2.tgz", + "integrity": "sha512-5YfKeeI8qWfBZIX+u2xZC3Zlb3Os/gLS2sbEKM+I4ZOcsWmHS2WLysCcQZDAFRslDUU5Oiq44gf6PYN1vGwG5A==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.2.tgz", + "integrity": "sha512-O387ite7SzUyCcy3JQX4P4bLtEA7bLLkx+esve5JHnyYfNTxcVpXZo9jhdB0lTKN44gztELTdU7nS8Nr16Fs1Q==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.2.tgz", + "integrity": "sha512-n4KqkOQrraxHJcgjM1RvwbigfQKIKJVpM7xp+KsxiyUSrRdIXnt73VhrPAx0fV44hgfmIVKjxMN9J1t5jySVkw==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.2.tgz", + "integrity": "sha512-uq6suIWYP37qzGddBKPw5QEQPi6HiLGsO7UmkpfyaYNQ3D+rN6w6WfwH+nuqcGXWvawGwxOEroO4YGnFh95azw==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.2.tgz", + "integrity": "sha512-n+I0BTSRIoy+d6RPKnEVwql5UwBJolytvY4mAOIEJorKlqgPII8ix6slVVrfZ5Tnj7glIZvloylbB/EJPMWEXw==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.2.tgz", + "integrity": "sha512-78XJTJkvPs0kz2w61301PJjXl4g7q3JqiYMZ/M/yVI73EHBrCRTgkhu9oqG7vPqq+a/yadEW8aD+agKlk5xrmg==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.2.tgz", + "integrity": "sha512-XlDnu2q5yoqems+xay6wSAcg9DDD7K9RLKZEBOMZm3ckNpJBvOX20tSfby8KfrrhINDyv9V2YVZKY/SpoGJI8w==", + "cpu": [ + "arm" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.2.tgz", + "integrity": "sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.2.tgz", + "integrity": "sha512-CYbnj78HsIeA+DhgUKgFCfvNsTHFhMMrinUrMZpDXJXKN8T3XViTZ/+wtHeVxEWY8ewSzTFN+nRmSwO2tZaLUQ==", + "cpu": [ + "ia32" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.2.tgz", + "integrity": "sha512-buwkd8nsph4R+ajRvw0qM5Hja/TXQow3ptzWO2EbG/cqcIkHloRrdlBtQlshyYGTNFvfkfJ5tpPLVkY4DtsPfQ==", + "cpu": [ + "loong64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.2.tgz", + "integrity": "sha512-ZVykbDyk7519VwiNb9Lcj9m8XM6v5V9uKPvrEMkkEedVewf+0itkhahp4HDpgERXhwLRpWFypsGbG/J8s0QjJA==", + "cpu": [ + "mips64el" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.2.tgz", + "integrity": "sha512-CAXl+Dtd9UUuJd8pKKdwh6MLm3MUMiqMPmhZ3tTSXPqfyQ3vDl6R5hZdZ/kYojK4ofXtdfSv1tFq8XzWx3heNQ==", + "cpu": [ + "ppc64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.2.tgz", + "integrity": "sha512-GeXCej4IQtU1B+QlDV8W/RRvbzI3O/Stss+/bCXv4lZls5WGRtu2a+3JkA3i4qIUlMXpcHebWpF8AkJhATowuA==", + "cpu": [ + "riscv64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.2.tgz", + "integrity": "sha512-3H1weTYZPxt/WOhByszQZybS9w5lKzUn1FDMsgEChbHWQwHYQQRfBxgCcZvPhjHfKyJjIievvMmEUawJrdY9Dg==", + "cpu": [ + "s390x" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.2.tgz", + "integrity": "sha512-4xTZr1FUmSoQW4XIWmit3tzQrUTZM+N3P0XV8xROKYF50XfI7xeO90+1bZvNwxIufQ9hDQVRJH5YhgPVF8A/HQ==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.2.tgz", + "integrity": "sha512-sSATRjPeDBg3pdgHoQfoYBob11Kk1FGa9lui5RIHZCoCkJa9QKlvl3/vKz2usCmYYjs7ymJR/2Nnsqe+Hjt5nw==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.2.tgz", + "integrity": "sha512-lqnzCV+mM0gIADaKihiCg6ifgfU2L3h5E33rNQBN1Y4MaVGnzryzmvvf7UHxprpQdE8hpqLolJ9Rl+SkIRDpyw==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.2.tgz", + "integrity": "sha512-AL2qJILH7lNjrDmCQDvdxMfAUIv8KMNZOvrwAQ8i8//ntL9FflhOyMJ8OZSMBb8/AWXe3/5v5S20y3zCoZWKoQ==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.2.tgz", + "integrity": "sha512-QtiuPytchRyC4rwUKhexJdQKvDuZ6hWloi3igqPQNUJCS1/v9EiO3UTOXR6A3FoMo4fnAKbWJdqaIwhOzh8qEw==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.2.tgz", + "integrity": "sha512-WkhYDmpTjLvGlScA1rwjRUmhl4k8oXR3cIbtqWmELgU/dFeHHlEllxDvdWcNJV9rbzCexB5vz8gtNewWLgCT7Q==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.2.tgz", + "integrity": "sha512-GPMSkTOtMnv2U2F8gxe4Io6qmVs+YKyp832Etqqxr0hFngmXQ3rzwytelm3GIn7T4VviRUlf3sOgBOiTdvaf7g==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.2.tgz", + "integrity": "sha512-PIhhEkE9uPBleRBrQEJpUn7MBnibZzbGzYWPmY3x+YoVg/95zbjB4CxPPOQ8l5tYYM4mMaCthF8/1DIfBQQyWQ==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.2.tgz", + "integrity": "sha512-YmJbfTlvU7Sdn9BB+4PRES4oB6pxgS37MAONj+hBr/cpXS1aBPKXxNnDbu+QCWPj0o9dgyxeq79g6c5P8KeuYA==", + "cpu": [ + "ia32" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.2.tgz", + "integrity": "sha512-5ebpxr3nWMzrL/rnUI755Jkuee0bHL/Gq0WTF9lvcpv73wAp5eu8MfBUgWK9bhWvZjj7yX8etf/8tI8Ney695g==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@eslint-community/eslint-utils": { + "version": "4.10.1", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.10.1.tgz", + "integrity": "sha512-cuadcxVFE8sDK6iWJbs8Sn0av2Nrh2QSGQhVlBW9AaAHqHwjWsZHT8LJ4hFGPh7ASBV2deFdM7H/DPjulmh8rg==", + "dev": true, + "license": "MIT", + "dependencies": { + "eslint-visitor-keys": "^3.4.3" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.12.2", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz", + "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz", + "integrity": "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^9.6.0", + "globals": "^13.19.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.0", + "minimatch": "^3.1.2", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint/eslintrc/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/@eslint/eslintrc/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@eslint/js": { + "version": "8.57.1", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.57.1.tgz", + "integrity": "sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + } + }, + "node_modules/@humanwhocodes/config-array": { + "version": "0.13.0", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.13.0.tgz", + "integrity": "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw==", + "deprecated": "Use @eslint/config-array instead", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@humanwhocodes/object-schema": "^2.0.3", + "debug": "^4.3.1", + "minimatch": "^3.0.5" + }, + "engines": { + "node": ">=10.10.0" + } + }, + "node_modules/@humanwhocodes/config-array/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/@humanwhocodes/config-array/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/object-schema": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz", + "integrity": "sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==", + "deprecated": "Use @eslint/object-schema instead", + "dev": true, + "license": "BSD-3-Clause" + }, + "node_modules/@img/colour": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.1.0.tgz", + "integrity": "sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==", + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/@img/sharp-darwin-arm64": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.35.5.tgz", + "integrity": "sha512-QRUlFQ0WxvdWyqqG/WtI3iupfD5rBzmCHXSdPsY91sAtVtTo7Q4cb6zOccZ3gqEqkr0f1As1ehLqmEpDsRf+lg==", + "cpu": [ + "arm64" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-darwin-arm64": "1.3.4" + } + }, + "node_modules/@img/sharp-darwin-x64": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.35.5.tgz", + "integrity": "sha512-+BR255RhDlpygUpOc/Jdt1nT6DQ3XG/ERo5wbcdOf5Q320dKtPCKPLR1LJs9VGXRaMa8l1uUa0tkCNOXiAxZUw==", + "cpu": [ + "x64" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-darwin-x64": "1.3.4" + } + }, + "node_modules/@img/sharp-freebsd-wasm32": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-freebsd-wasm32/-/sharp-freebsd-wasm32-0.35.5.tgz", + "integrity": "sha512-Y/z91nEZ4uIBX5X3nfTovjU9lHNKFYbL2lpHCLVNmXQK03VIZvXBBt0KxbPGp2SdGSF+2mQU4e+hQaWOt86iAw==", + "license": "Apache-2.0", + "optional": true, + "os": [ + "freebsd" + ], + "dependencies": { + "@img/sharp-wasm32": "0.35.5" + }, + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-darwin-arm64": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.3.4.tgz", + "integrity": "sha512-5R89nBYiRdUlSWJxPhO+GVtaXzXSxKnRu/xqMn3KTA3L9EB9Oy/P+Nn2f2vlhPuUdy/Zusb2DarbyTpGCfEDuw==", + "cpu": [ + "arm64" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "darwin" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-darwin-x64": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.3.4.tgz", + "integrity": "sha512-iR2OKH80yi0U+dUplyh3/xdpFvps6YkCwsXenIJxqxR1v9o+xtKTGbS9H7cps+2Vxjc8B1j96p75NmTGjIhtpQ==", + "cpu": [ + "x64" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "darwin" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linux-arm": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.3.4.tgz", + "integrity": "sha512-LmRtTsOHuvM2+wlO2Db37dx5MiZhB0FvSunciw48YjdOkZz9KAiRbm8ujeMOA1INqmei5NapFxYEK1D1ZSidmw==", + "cpu": [ + "arm" + ], + "libc": [ + "glibc" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linux-arm64": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.3.4.tgz", + "integrity": "sha512-Y3dgX/6lE2QhQb+Gxy0WZxfg9MEm/JBjamZpS2IklP7xIQoKN4hzAm7KcMVGtaVDt3neE9OKBC7vAfonA/Lr1A==", + "cpu": [ + "arm64" + ], + "libc": [ + "glibc" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linux-ppc64": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-ppc64/-/sharp-libvips-linux-ppc64-1.3.4.tgz", + "integrity": "sha512-Le6boB8Tai0Nis+gIxIpKx68UDVVIqdR8Tin5Yf1z2LJJQLDJvCDRqRu+jC2qCoD+eIomonmOwB4smBRxfVpYQ==", + "cpu": [ + "ppc64" + ], + "libc": [ + "glibc" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linux-riscv64": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-riscv64/-/sharp-libvips-linux-riscv64-1.3.4.tgz", + "integrity": "sha512-aHkkIEHPRdQEegJN20MLmGtxYD9R2wQr3Cwpddnu5+YKMt6Uzax7S9h5gpZTo8wyrGuZSlfQ63OevL5mTyOC7Q==", + "cpu": [ + "riscv64" + ], + "libc": [ + "glibc" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linux-s390x": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.3.4.tgz", + "integrity": "sha512-ra/mB6MikESDUO7Yg+Mi95bFBb9GsObURuhnOv3OqknjGe9sZrG8tCe9q0xSIGrtLgvgw0gKnFWcK4blSgQOuQ==", + "cpu": [ + "s390x" + ], + "libc": [ + "glibc" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linux-x64": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.3.4.tgz", + "integrity": "sha512-GJ//SSXbnwSDes02umB3nDJLFcQzw8a18V8fyhqr6tV515tOEMdImjjxj1AoafMRz56F3PHgftnj1QEKSU1zkw==", + "cpu": [ + "x64" + ], + "libc": [ + "glibc" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linuxmusl-arm64": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.3.4.tgz", + "integrity": "sha512-hvulFwtjUcagsis6BBxHwGFwWoNZjgYmULGVrZcyfNbjA8hKILbRxGg15/7w5HDyXHXUos/j6baAWqnCyQ2DWA==", + "cpu": [ + "arm64" + ], + "libc": [ + "musl" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linuxmusl-x64": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.3.4.tgz", + "integrity": "sha512-6zXKeE/p39I1AmA3cJG35eyBGNqNddLnUXjhwBnsGjFPWqf5VKkDBEqaEkPDoTEtkxwi2vv8Tcr2mDyP4So7Fg==", + "cpu": [ + "x64" + ], + "libc": [ + "musl" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-linux-arm": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.35.5.tgz", + "integrity": "sha512-LEaXK2WdXVK5ykcw0buWyPMsmLLL2vpHLD6yrNSW+JGEL3BZPA4tpKN6iaMc4AxTTAoaX/sU1rOL51lcIz48ZQ==", + "cpu": [ + "arm" + ], + "libc": [ + "glibc" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linux-arm": "1.3.4" + } + }, + "node_modules/@img/sharp-linux-arm64": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.35.5.tgz", + "integrity": "sha512-LYVx5JTsOM2CBzmxreh+nl64/3H6Xb09iSLknqH47z2T2DFFxDeFLP5y4dJwe6H7uGQlHPyEEtIqyo3DYsRwdQ==", + "cpu": [ + "arm64" + ], + "libc": [ + "glibc" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linux-arm64": "1.3.4" + } + }, + "node_modules/@img/sharp-linux-ppc64": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-linux-ppc64/-/sharp-linux-ppc64-0.35.5.tgz", + "integrity": "sha512-QVxAAq8evVRI9ia2vqgwrmWucn5Dfv+JdWzj75pD8omHLPSP7f8p20O8jxzjCcuCEQEOtYOZUmX1hkiZ0kdevA==", + "cpu": [ + "ppc64" + ], + "libc": [ + "glibc" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linux-ppc64": "1.3.4" + } + }, + "node_modules/@img/sharp-linux-riscv64": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-linux-riscv64/-/sharp-linux-riscv64-0.35.5.tgz", + "integrity": "sha512-LtdreXguaavKODPIfzJ4kffx7UNt1omwtK0rch4EBbbSTXPnxWmYSayXdLJw0fJzQ97kHt1gL/yh4tvU+nCyRQ==", + "cpu": [ + "riscv64" + ], + "libc": [ + "glibc" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linux-riscv64": "1.3.4" + } + }, + "node_modules/@img/sharp-linux-s390x": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.35.5.tgz", + "integrity": "sha512-UZasTOFiYzotTsGOCu42BfUzP6Tu6Do/947iRm1RsLKvlllxwGcn4RN27LibGWceix4Y+Pmw3jsnTcCQIgWjqA==", + "cpu": [ + "s390x" + ], + "libc": [ + "glibc" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linux-s390x": "1.3.4" + } + }, + "node_modules/@img/sharp-linux-x64": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.35.5.tgz", + "integrity": "sha512-SxFtLTeJInhAA9Q836kux2vZNeOBQEx658qvbboZScr0wIARym3IcGmW7KpVD5sbVg0Ojy+udFQdayYIZyoNog==", + "cpu": [ + "x64" + ], + "libc": [ + "glibc" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linux-x64": "1.3.4" + } + }, + "node_modules/@img/sharp-linuxmusl-arm64": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.35.5.tgz", + "integrity": "sha512-9HbMclmI1zlNkFRs3z9/eBtDjfD0sGlrX1z6b1qwmiFY5ElDLh4BC0LPBdVp7z1DXFiKlIcznf+ZlsuZzLxQqg==", + "cpu": [ + "arm64" + ], + "libc": [ + "musl" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linuxmusl-arm64": "1.3.4" + } + }, + "node_modules/@img/sharp-linuxmusl-x64": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.35.5.tgz", + "integrity": "sha512-4KOphqB035HrVdqLZfCgMzzERrQkkzOwRhl4OAkRO1YCldbaFjySXMaK534Mo0V+LndnlJk+sbUyLeU0ULyD1A==", + "cpu": [ + "x64" + ], + "libc": [ + "musl" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linuxmusl-x64": "1.3.4" + } + }, + "node_modules/@img/sharp-wasm32": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.35.5.tgz", + "integrity": "sha512-Ptsga1su4tQx+LLF1ECS9U6nz5kmrXKo6XVbtR48Ke3ZRxxgaWBu7IDtEe1quo8hiupwm6WFqxVlXaSf7IINGQ==", + "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT", + "optional": true, + "dependencies": { + "@emnapi/runtime": "^1.11.3" + }, + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-webcontainers-wasm32": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-webcontainers-wasm32/-/sharp-webcontainers-wasm32-0.35.5.tgz", + "integrity": "sha512-hfhF/FmoQyTUkA0bIKFOtw536BQSeBMe6BF6QyWlrPxT754+TFLaZ7sKKTfvvM0yJgKgaYTwnFCIZ/GuDw5SUA==", + "cpu": [ + "wasm32" + ], + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@img/sharp-wasm32": "0.35.5" + }, + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-win32-arm64": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-win32-arm64/-/sharp-win32-arm64-0.35.5.tgz", + "integrity": "sha512-X4t7g+7ZA5DKblCBEXGjUqqemj4vczING/5viFwAL8h4N3qYeyjwdCvRLHi4EdOUI+2Z7UFlp1VM+p/AuEtm6Q==", + "cpu": [ + "arm64" + ], + "license": "Apache-2.0 AND LGPL-3.0-or-later", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-win32-ia32": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.35.5.tgz", + "integrity": "sha512-5Zm82LoBc43nhwNybZlG7Y1KO//Zhsn306fQl29ZOuStHLGTo3BWL83q3cznX0poxSAMuYL1On/BHBxkBeKr6A==", + "cpu": [ + "ia32" + ], + "license": "Apache-2.0 AND LGPL-3.0-or-later", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-win32-x64": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.35.5.tgz", + "integrity": "sha512-x76eH0vEiHlcMQu8Y8IenntaACtddpT6W0wmXtWrnKcnKI7ME5DdgqhAD6SEWOEl1v2zDvkZDhFA9KnURwpfqg==", + "cpu": [ + "x64" + ], + "license": "Apache-2.0 AND LGPL-3.0-or-later", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/source-map": { + "version": "0.3.11", + "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.11.tgz", + "integrity": "sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==", + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.25" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz", + "integrity": "sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw==", + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@mongodb-js/saslprep": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/@mongodb-js/saslprep/-/saslprep-1.6.1.tgz", + "integrity": "sha512-D4CQtk9IwjCLAvCf1xvHEod3960q8XMUzfmdRU9qjUNlHnesGuTOvJcOTaPm9koZ1caUKA2aTbszZiAkcmSgmg==", + "license": "MIT", + "optional": true, + "dependencies": { + "sparse-bitfield": "^3.0.3" + } + }, + "node_modules/@noble/hashes": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.8.0.tgz", + "integrity": "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==", + "license": "MIT", + "engines": { + "node": "^14.21.3 || >=16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@noble/secp256k1": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-3.2.0.tgz", + "integrity": "sha512-Z3ZAWOTxJ0EuTuZTi7Y69iK7GgrLHh8sgm45lVDhg/b3Nk1TpAiKhick2KkZisHuupeepSkyIydN/J459SdX1w==", + "license": "MIT", + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@scure/base": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@scure/base/-/base-1.2.6.tgz", + "integrity": "sha512-g/nm5FgUa//MCj1gV09zTJTaM6KBAHqLN907YVQqf7zC49+DcO4B1so4ZX07Ef10Twr6nuqYEH9GEggFXA4Fmg==", + "license": "MIT", + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@sindresorhus/is": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz", + "integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sindresorhus/is?sponsor=1" + } + }, + "node_modules/@smithy/core": { + "version": "3.37.0", + "resolved": "https://registry.npmjs.org/@smithy/core/-/core-3.37.0.tgz", + "integrity": "sha512-97imTcCyiPd8k0e9+ts/Sp0W65Dn9Ti357J7M09Ov4tI8Q1JDJVFSoAJtjEVKqfHEr3Pdo2jfolqKCaaiszH0g==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/@smithy/credential-provider-imds": { + "version": "4.5.2", + "resolved": "https://registry.npmjs.org/@smithy/credential-provider-imds/-/credential-provider-imds-4.5.2.tgz", + "integrity": "sha512-A9uSdn72ozbRUSit0eib0TW7nXuNPlaeM0zcGkJ+nE6tFcSDbnmtwoxbTCFBukVQcszDAyvsd7+rTduPTXpygg==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@smithy/core": "^3.33.2", + "@smithy/types": "^4.17.2", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/@smithy/fetch-http-handler": { + "version": "5.8.0", + "resolved": "https://registry.npmjs.org/@smithy/fetch-http-handler/-/fetch-http-handler-5.8.0.tgz", + "integrity": "sha512-ycSJu3tFAQ4v04CBB0agqFMVsSQ1iG3yw+SpgxRqKfaURpQD4CZ8Wn0zPMmSnOuTpTh65Vz+EA0rMrw089wvkA==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@smithy/core": "^3.33.3", + "@smithy/types": "^4.18.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/@smithy/is-array-buffer": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/@smithy/is-array-buffer/-/is-array-buffer-2.2.0.tgz", + "integrity": "sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA==", + "license": "Apache-2.0", + "dependencies": { + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/@smithy/node-http-handler": { + "version": "4.13.0", + "resolved": "https://registry.npmjs.org/@smithy/node-http-handler/-/node-http-handler-4.13.0.tgz", + "integrity": "sha512-/GGcPoNJ2nzGytdAanpbx7mpp9Coa8LP+/Rpmbktr8YeLuIXs9B0SEz+X3AeonHdyzOIFJdKbN7jOZ+Tj+pMGw==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@smithy/core": "^3.37.0", + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/@smithy/signature-v4": { + "version": "5.7.4", + "resolved": "https://registry.npmjs.org/@smithy/signature-v4/-/signature-v4-5.7.4.tgz", + "integrity": "sha512-tHy0K0VtqNd5Y7Y41h0a0Lhh0L1GzC08dTWg0F7vRJWFtTENg7IZikf3wQkanYIRdb7ngoIPMTmqgUi401fEeQ==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@smithy/core": "^3.35.0", + "@smithy/types": "^4.19.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/@smithy/types": { + "version": "4.19.0", + "resolved": "https://registry.npmjs.org/@smithy/types/-/types-4.19.0.tgz", + "integrity": "sha512-r7jh49VJxGerfAcTQA6gXcKc+98zOp/tqRwzYjgOE+iSQsP6cEU1hq2QzbuipmP68QtYdY9wKEhiCQZIzHgZ4Q==", + "license": "Apache-2.0", + "dependencies": { + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/@smithy/util-buffer-from": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/@smithy/util-buffer-from/-/util-buffer-from-2.2.0.tgz", + "integrity": "sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA==", + "license": "Apache-2.0", + "dependencies": { + "@smithy/is-array-buffer": "^2.2.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/@smithy/util-utf8": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/@smithy/util-utf8/-/util-utf8-2.3.0.tgz", + "integrity": "sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A==", + "license": "Apache-2.0", + "dependencies": { + "@smithy/util-buffer-from": "^2.2.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/@so-ric/colorspace": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@so-ric/colorspace/-/colorspace-1.1.6.tgz", + "integrity": "sha512-/KiKkpHNOBgkFJwu9sh48LkHSMYGyuTcSFK/qMBdnOAlrRJzRSXAOFB5qwzaVQuDl8wAvHVMkaASQDReTahxuw==", + "dev": true, + "license": "MIT", + "dependencies": { + "color": "^5.0.2", + "text-hex": "1.0.x" + } + }, + "node_modules/@szmarczak/http-timer": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-4.0.6.tgz", + "integrity": "sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==", + "license": "MIT", + "dependencies": { + "defer-to-connect": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@types/cacheable-request": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/@types/cacheable-request/-/cacheable-request-6.0.3.tgz", + "integrity": "sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==", + "license": "MIT", + "dependencies": { + "@types/http-cache-semantics": "*", + "@types/keyv": "^3.1.4", + "@types/node": "*", + "@types/responselike": "^1.0.0" + } + }, + "node_modules/@types/estree": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz", + "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==", + "license": "MIT" + }, + "node_modules/@types/http-cache-semantics": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz", + "integrity": "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==", + "license": "MIT" + }, + "node_modules/@types/json-schema": { + "version": "7.0.15", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "license": "MIT" + }, + "node_modules/@types/keyv": { + "version": "3.1.4", + "resolved": "https://registry.npmjs.org/@types/keyv/-/keyv-3.1.4.tgz", + "integrity": "sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/node": { + "version": "26.6.6", + "resolved": "https://registry.npmjs.org/@types/node/-/node-26.6.6.tgz", + "integrity": "sha512-MzQj+8Kx3XI40OmUAE6Qoh58ZMNstNNMwn2nfd3qWsfe7nDNSqJNzes4njhz6AHwrSHOffSLwXU6yb474Q4aog==", + "license": "MIT", + "dependencies": { + "undici-types": "~8.9.0" + } + }, + "node_modules/@types/responselike": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@types/responselike/-/responselike-1.0.3.tgz", + "integrity": "sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/triple-beam": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@types/triple-beam/-/triple-beam-1.3.5.tgz", + "integrity": "sha512-6WaYesThRMCl19iryMYP7/x2OVgCtbIVflDGFpWnb9irXI3UjYE4AzmYuiUKY1AJstGijoY+MgUszMgRxIYTYw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/webidl-conversions": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/@types/webidl-conversions/-/webidl-conversions-7.0.3.tgz", + "integrity": "sha512-CiJJvcRtIgzadHCYXw7dqEnMNRjhGZlYK05Mj9OyktqV8uVT8fD2BFOB7S1uwBE3Kj2Z+4UyPmFw/Ixgw/LAlA==", + "license": "MIT" + }, + "node_modules/@types/whatwg-url": { + "version": "8.2.2", + "resolved": "https://registry.npmjs.org/@types/whatwg-url/-/whatwg-url-8.2.2.tgz", + "integrity": "sha512-FtQu10RWgn3D9U4aazdwIE2yzphmTJREDqNdODHrbrZmmMqI0vMheC/6NE/J1Yveaj8H+ela+YwWTjq5PGmuhA==", + "license": "MIT", + "dependencies": { + "@types/node": "*", + "@types/webidl-conversions": "*" + } + }, + "node_modules/@ungap/structured-clone": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.4.0.tgz", + "integrity": "sha512-1mEZtMKPM09vDmQt5y7YvmN2+DFTP7Tg0EWXdic8/C6VRnpb33e4ghisCIE3WZjsE2N8mf+QV1Zqh7ZFYLWInQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/@webassemblyjs/ast": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.14.1.tgz", + "integrity": "sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/helper-numbers": "1.13.2", + "@webassemblyjs/helper-wasm-bytecode": "1.13.2" + } + }, + "node_modules/@webassemblyjs/floating-point-hex-parser": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.13.2.tgz", + "integrity": "sha512-6oXyTOzbKxGH4steLbLNOu71Oj+C8Lg34n6CqRvqfS2O71BxY6ByfMDRhBytzknj9yGUPVJ1qIKhRlAwO1AovA==", + "license": "MIT" + }, + "node_modules/@webassemblyjs/helper-api-error": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.13.2.tgz", + "integrity": "sha512-U56GMYxy4ZQCbDZd6JuvvNV/WFildOjsaWD3Tzzvmw/mas3cXzRJPMjP83JqEsgSbyrmaGjBfDtV7KDXV9UzFQ==", + "license": "MIT" + }, + "node_modules/@webassemblyjs/helper-buffer": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.14.1.tgz", + "integrity": "sha512-jyH7wtcHiKssDtFPRB+iQdxlDf96m0E39yb0k5uJVhFGleZFoNw1c4aeIcVUPPbXUVJ94wwnMOAqUHyzoEPVMA==", + "license": "MIT" + }, + "node_modules/@webassemblyjs/helper-numbers": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.13.2.tgz", + "integrity": "sha512-FE8aCmS5Q6eQYcV3gI35O4J789wlQA+7JrqTTpJqn5emA4U2hvwJmvFRC0HODS+3Ye6WioDklgd6scJ3+PLnEA==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/floating-point-hex-parser": "1.13.2", + "@webassemblyjs/helper-api-error": "1.13.2", + "@xtuc/long": "4.2.2" + } + }, + "node_modules/@webassemblyjs/helper-wasm-bytecode": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.13.2.tgz", + "integrity": "sha512-3QbLKy93F0EAIXLh0ogEVR6rOubA9AoZ+WRYhNbFyuB70j3dRdwH9g+qXhLAO0kiYGlg3TxDV+I4rQTr/YNXkA==", + "license": "MIT" + }, + "node_modules/@webassemblyjs/helper-wasm-section": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.14.1.tgz", + "integrity": "sha512-ds5mXEqTJ6oxRoqjhWDU83OgzAYjwsCV8Lo/N+oRsNDmx/ZDpqalmrtgOMkHwxsG0iI//3BwWAErYRHtgn0dZw==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.14.1", + "@webassemblyjs/helper-buffer": "1.14.1", + "@webassemblyjs/helper-wasm-bytecode": "1.13.2", + "@webassemblyjs/wasm-gen": "1.14.1" + } + }, + "node_modules/@webassemblyjs/ieee754": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.13.2.tgz", + "integrity": "sha512-4LtOzh58S/5lX4ITKxnAK2USuNEvpdVV9AlgGQb8rJDHaLeHciwG4zlGr0j/SNWlr7x3vO1lDEsuePvtcDNCkw==", + "license": "MIT", + "dependencies": { + "@xtuc/ieee754": "^1.2.0" + } + }, + "node_modules/@webassemblyjs/leb128": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.13.2.tgz", + "integrity": "sha512-Lde1oNoIdzVzdkNEAWZ1dZ5orIbff80YPdHx20mrHwHrVNNTjNr8E3xz9BdpcGqRQbAEa+fkrCb+fRFTl/6sQw==", + "license": "Apache-2.0", + "dependencies": { + "@xtuc/long": "4.2.2" + } + }, + "node_modules/@webassemblyjs/utf8": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.13.2.tgz", + "integrity": "sha512-3NQWGjKTASY1xV5m7Hr0iPeXD9+RDobLll3T9d2AO+g3my8xy5peVyjSag4I50mR1bBSN/Ct12lo+R9tJk0NZQ==", + "license": "MIT" + }, + "node_modules/@webassemblyjs/wasm-edit": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.14.1.tgz", + "integrity": "sha512-RNJUIQH/J8iA/1NzlE4N7KtyZNHi3w7at7hDjvRNm5rcUXa00z1vRz3glZoULfJ5mpvYhLybmVcwcjGrC1pRrQ==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.14.1", + "@webassemblyjs/helper-buffer": "1.14.1", + "@webassemblyjs/helper-wasm-bytecode": "1.13.2", + "@webassemblyjs/helper-wasm-section": "1.14.1", + "@webassemblyjs/wasm-gen": "1.14.1", + "@webassemblyjs/wasm-opt": "1.14.1", + "@webassemblyjs/wasm-parser": "1.14.1", + "@webassemblyjs/wast-printer": "1.14.1" + } + }, + "node_modules/@webassemblyjs/wasm-gen": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.14.1.tgz", + "integrity": "sha512-AmomSIjP8ZbfGQhumkNvgC33AY7qtMCXnN6bL2u2Js4gVCg8fp735aEiMSBbDR7UQIj90n4wKAFUSEd0QN2Ukg==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.14.1", + "@webassemblyjs/helper-wasm-bytecode": "1.13.2", + "@webassemblyjs/ieee754": "1.13.2", + "@webassemblyjs/leb128": "1.13.2", + "@webassemblyjs/utf8": "1.13.2" + } + }, + "node_modules/@webassemblyjs/wasm-opt": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.14.1.tgz", + "integrity": "sha512-PTcKLUNvBqnY2U6E5bdOQcSM+oVP/PmrDY9NzowJjislEjwP/C4an2303MCVS2Mg9d3AJpIGdUFIQQWbPds0Sw==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.14.1", + "@webassemblyjs/helper-buffer": "1.14.1", + "@webassemblyjs/wasm-gen": "1.14.1", + "@webassemblyjs/wasm-parser": "1.14.1" + } + }, + "node_modules/@webassemblyjs/wasm-parser": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz", + "integrity": "sha512-JLBl+KZ0R5qB7mCnud/yyX08jWFw5MsoalJ1pQ4EdFlgj9VdXKGuENGsiCIjegI1W7p91rUlcB/LB5yRJKNTcQ==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.14.1", + "@webassemblyjs/helper-api-error": "1.13.2", + "@webassemblyjs/helper-wasm-bytecode": "1.13.2", + "@webassemblyjs/ieee754": "1.13.2", + "@webassemblyjs/leb128": "1.13.2", + "@webassemblyjs/utf8": "1.13.2" + } + }, + "node_modules/@webassemblyjs/wast-printer": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.14.1.tgz", + "integrity": "sha512-kPSSXE6De1XOR820C90RIo2ogvZG+c3KiHzqUoO/F34Y2shGzesfqv7o57xrxovZJH/MetF5UjroJ/R/3isoiw==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.14.1", + "@xtuc/long": "4.2.2" + } + }, + "node_modules/@webpack-cli/configtest": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@webpack-cli/configtest/-/configtest-1.2.0.tgz", + "integrity": "sha512-4FB8Tj6xyVkyqjj1OaTqCjXYULB9FMkqQ8yGrZjRDrYh0nOE+7Lhs45WioWQQMV+ceFlE368Ukhe6xdvJM9Egg==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "webpack": "4.x.x || 5.x.x", + "webpack-cli": "4.x.x" + } + }, + "node_modules/@webpack-cli/info": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@webpack-cli/info/-/info-1.5.0.tgz", + "integrity": "sha512-e8tSXZpw2hPl2uMJY6fsMswaok5FdlGNRTktvFk2sD8RjH0hE2+XistawJx1vmKteh4NmGmNUrp+Tb2w+udPcQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "envinfo": "^7.7.3" + }, + "peerDependencies": { + "webpack-cli": "4.x.x" + } + }, + "node_modules/@webpack-cli/serve": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/@webpack-cli/serve/-/serve-1.7.0.tgz", + "integrity": "sha512-oxnCNGj88fL+xzV+dacXs44HcDwf1ovs3AuEzvP7mqXw7fQntqIhQ1BRmynh4qEKQSSSRSWVyXRjmTbZIX9V2Q==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "webpack-cli": "4.x.x" + }, + "peerDependenciesMeta": { + "webpack-dev-server": { + "optional": true + } + } + }, + "node_modules/@xtuc/ieee754": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz", + "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==", + "license": "BSD-3-Clause" + }, + "node_modules/@xtuc/long": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz", + "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==", + "license": "Apache-2.0" + }, + "node_modules/accepts": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz", + "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==", + "license": "MIT", + "dependencies": { + "mime-types": "~2.1.34", + "negotiator": "0.6.3" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/acorn": { + "version": "8.19.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.19.0.tgz", + "integrity": "sha512-oJlA3XiRm7Cyk6qFD2Jn8ak9B7jSy0qy00ADO3+8dpT0LSjFihQYv4C02LFCSYJV3Q37xYwwRy5m+IpIiUzqWw==", + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/ajv": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.15.0.tgz", + "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ajv-formats": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz", + "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==", + "license": "MIT", + "dependencies": { + "ajv": "^8.0.0" + }, + "peerDependencies": { + "ajv": "^8.0.0" + }, + "peerDependenciesMeta": { + "ajv": { + "optional": true + } + } + }, + "node_modules/ajv-formats/node_modules/ajv": { + "version": "8.20.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.20.0.tgz", + "integrity": "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.3", + "fast-uri": "^3.0.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ajv-formats/node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", + "license": "MIT" + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dev": true, + "license": "ISC", + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/apidoc": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/apidoc/-/apidoc-1.2.0.tgz", + "integrity": "sha512-Qagoj7QnqNHbDUDNpU21eLP4hJSAXn6knHtEjRYWTlSEmpYDGSQijejyFXaWGByhfryW8B1gL+6B57UB/F1lxw==", + "dev": true, + "license": "MIT", + "os": [ + "darwin", + "freebsd", + "linux", + "openbsd", + "win32" + ], + "dependencies": { + "bootstrap": "3.4.1", + "commander": "^10.0.0", + "diff-match-patch": "^1.0.5", + "esbuild-loader": "^2.16.0", + "expose-loader": "^4.0.0", + "fs-extra": "^11.0.0", + "glob": "^7.2.0", + "handlebars": "^4.7.7", + "iconv-lite": "^0.6.3", + "jquery": "^3.6.0", + "klaw-sync": "^6.0.0", + "lodash": "^4.17.21", + "markdown-it": "^12.2.0", + "nodemon": "^3.0.1", + "prismjs": "^1.25.0", + "semver": "^7.5.0", + "style-loader": "^3.3.1", + "webpack": "^5.64.2", + "webpack-cli": "^4.9.1", + "winston": "^3.3.3" + }, + "bin": { + "apidoc": "bin/apidoc" + }, + "engines": { + "node": ">=16.0.0" + } + }, + "node_modules/apidoc/node_modules/@esbuild/android-arm": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.16.17.tgz", + "integrity": "sha512-N9x1CMXVhtWEAMS7pNNONyA14f71VPQN9Cnavj1XQh6T7bskqiLLrSca4O0Vr8Wdcga943eThxnVp3JLnBMYtw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/android-arm64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.16.17.tgz", + "integrity": "sha512-MIGl6p5sc3RDTLLkYL1MyL8BMRN4tLMRCn+yRJJmEDvYZ2M7tmAf80hx1kbNEUX2KJ50RRtxZ4JHLvCfuB6kBg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/android-x64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.16.17.tgz", + "integrity": "sha512-a3kTv3m0Ghh4z1DaFEuEDfz3OLONKuFvI4Xqczqx4BqLyuFaFkuaG4j2MtA6fuWEFeC5x9IvqnX7drmRq/fyAQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/darwin-arm64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.16.17.tgz", + "integrity": "sha512-/2agbUEfmxWHi9ARTX6OQ/KgXnOWfsNlTeLcoV7HSuSTv63E4DqtAc+2XqGw1KHxKMHGZgbVCZge7HXWX9Vn+w==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/darwin-x64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.16.17.tgz", + "integrity": "sha512-2By45OBHulkd9Svy5IOCZt376Aa2oOkiE9QWUK9fe6Tb+WDr8hXL3dpqi+DeLiMed8tVXspzsTAvd0jUl96wmg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/freebsd-arm64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.16.17.tgz", + "integrity": "sha512-mt+cxZe1tVx489VTb4mBAOo2aKSnJ33L9fr25JXpqQqzbUIw/yzIzi+NHwAXK2qYV1lEFp4OoVeThGjUbmWmdw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/freebsd-x64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.16.17.tgz", + "integrity": "sha512-8ScTdNJl5idAKjH8zGAsN7RuWcyHG3BAvMNpKOBaqqR7EbUhhVHOqXRdL7oZvz8WNHL2pr5+eIT5c65kA6NHug==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/linux-arm": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.16.17.tgz", + "integrity": "sha512-iihzrWbD4gIT7j3caMzKb/RsFFHCwqqbrbH9SqUSRrdXkXaygSZCZg1FybsZz57Ju7N/SHEgPyaR0LZ8Zbe9gQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/linux-arm64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.16.17.tgz", + "integrity": "sha512-7S8gJnSlqKGVJunnMCrXHU9Q8Q/tQIxk/xL8BqAP64wchPCTzuM6W3Ra8cIa1HIflAvDnNOt2jaL17vaW+1V0g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/linux-ia32": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.16.17.tgz", + "integrity": "sha512-kiX69+wcPAdgl3Lonh1VI7MBr16nktEvOfViszBSxygRQqSpzv7BffMKRPMFwzeJGPxcio0pdD3kYQGpqQ2SSg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/linux-loong64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.16.17.tgz", + "integrity": "sha512-dTzNnQwembNDhd654cA4QhbS9uDdXC3TKqMJjgOWsC0yNCbpzfWoXdZvp0mY7HU6nzk5E0zpRGGx3qoQg8T2DQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/linux-mips64el": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.16.17.tgz", + "integrity": "sha512-ezbDkp2nDl0PfIUn0CsQ30kxfcLTlcx4Foz2kYv8qdC6ia2oX5Q3E/8m6lq84Dj/6b0FrkgD582fJMIfHhJfSw==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/linux-ppc64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.16.17.tgz", + "integrity": "sha512-dzS678gYD1lJsW73zrFhDApLVdM3cUF2MvAa1D8K8KtcSKdLBPP4zZSLy6LFZ0jYqQdQ29bjAHJDgz0rVbLB3g==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/linux-riscv64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.16.17.tgz", + "integrity": "sha512-ylNlVsxuFjZK8DQtNUwiMskh6nT0vI7kYl/4fZgV1llP5d6+HIeL/vmmm3jpuoo8+NuXjQVZxmKuhDApK0/cKw==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/linux-s390x": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.16.17.tgz", + "integrity": "sha512-gzy7nUTO4UA4oZ2wAMXPNBGTzZFP7mss3aKR2hH+/4UUkCOyqmjXiKpzGrY2TlEUhbbejzXVKKGazYcQTZWA/w==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/linux-x64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.16.17.tgz", + "integrity": "sha512-mdPjPxfnmoqhgpiEArqi4egmBAMYvaObgn4poorpUaqmvzzbvqbowRllQ+ZgzGVMGKaPkqUmPDOOFQRUFDmeUw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/netbsd-x64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.16.17.tgz", + "integrity": "sha512-/PzmzD/zyAeTUsduZa32bn0ORug+Jd1EGGAUJvqfeixoEISYpGnAezN6lnJoskauoai0Jrs+XSyvDhppCPoKOA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/openbsd-x64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.16.17.tgz", + "integrity": "sha512-2yaWJhvxGEz2RiftSk0UObqJa/b+rIAjnODJgv2GbGGpRwAfpgzyrg1WLK8rqA24mfZa9GvpjLcBBg8JHkoodg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/sunos-x64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.16.17.tgz", + "integrity": "sha512-xtVUiev38tN0R3g8VhRfN7Zl42YCJvyBhRKw1RJjwE1d2emWTVToPLNEQj/5Qxc6lVFATDiy6LjVHYhIPrLxzw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/win32-arm64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.16.17.tgz", + "integrity": "sha512-ga8+JqBDHY4b6fQAmOgtJJue36scANy4l/rL97W+0wYmijhxKetzZdKOJI7olaBaMhWt8Pac2McJdZLxXWUEQw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/win32-ia32": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.16.17.tgz", + "integrity": "sha512-WnsKaf46uSSF/sZhwnqE4L/F89AYNMiD4YtEcYekBt9Q7nj0DiId2XH2Ng2PHM54qi5oPrQ8luuzGszqi/veig==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/@esbuild/win32-x64": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.16.17.tgz", + "integrity": "sha512-y+EHuSchhL7FjHgvQL/0fnnFmO4T1bhvWANX6gcnqTjtnKWbTvUMCpGnv2+t+31d7RzyEAYAd4u2fnIhHL6N/Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/apidoc/node_modules/commander": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz", + "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14" + } + }, + "node_modules/apidoc/node_modules/esbuild": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.16.17.tgz", + "integrity": "sha512-G8LEkV0XzDMNwXKgM0Jwu3nY3lSTwSGY6XbxM9cr9+s0T/qSV1q1JVPBGzm3dcjhCic9+emZDmMffkwgPeOeLg==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/android-arm": "0.16.17", + "@esbuild/android-arm64": "0.16.17", + "@esbuild/android-x64": "0.16.17", + "@esbuild/darwin-arm64": "0.16.17", + "@esbuild/darwin-x64": "0.16.17", + "@esbuild/freebsd-arm64": "0.16.17", + "@esbuild/freebsd-x64": "0.16.17", + "@esbuild/linux-arm": "0.16.17", + "@esbuild/linux-arm64": "0.16.17", + "@esbuild/linux-ia32": "0.16.17", + "@esbuild/linux-loong64": "0.16.17", + "@esbuild/linux-mips64el": "0.16.17", + "@esbuild/linux-ppc64": "0.16.17", + "@esbuild/linux-riscv64": "0.16.17", + "@esbuild/linux-s390x": "0.16.17", + "@esbuild/linux-x64": "0.16.17", + "@esbuild/netbsd-x64": "0.16.17", + "@esbuild/openbsd-x64": "0.16.17", + "@esbuild/sunos-x64": "0.16.17", + "@esbuild/win32-arm64": "0.16.17", + "@esbuild/win32-ia32": "0.16.17", + "@esbuild/win32-x64": "0.16.17" + } + }, + "node_modules/apidoc/node_modules/esbuild-loader": { + "version": "2.21.0", + "resolved": "https://registry.npmjs.org/esbuild-loader/-/esbuild-loader-2.21.0.tgz", + "integrity": "sha512-k7ijTkCT43YBSZ6+fBCW1Gin7s46RrJ0VQaM8qA7lq7W+OLsGgtLyFV8470FzYi/4TeDexniTBTPTwZUnXXR5g==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.16.17", + "joycon": "^3.0.1", + "json5": "^2.2.0", + "loader-utils": "^2.0.0", + "tapable": "^2.2.0", + "webpack-sources": "^1.4.3" + }, + "funding": { + "url": "https://github.com/privatenumber/esbuild-loader?sponsor=1" + }, + "peerDependencies": { + "webpack": "^4.40.0 || ^5.0.0" + } + }, + "node_modules/apidoc/node_modules/webpack-sources": { + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-1.4.3.tgz", + "integrity": "sha512-lgTS3Xhv1lCOKo7SA5TjKXMjpSM4sBjNV5+q2bqesbSPs5FjGmU6jjtBSkX9b4qW87vDIsCIlUPOEhbZrMdjeQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "source-list-map": "^2.0.0", + "source-map": "~0.6.1" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true, + "license": "Python-2.0" + }, + "node_modules/array-flatten": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", + "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==", + "license": "MIT" + }, + "node_modules/async": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz", + "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==", + "dev": true, + "license": "MIT" + }, + "node_modules/available-typed-arrays": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz", + "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==", + "license": "MIT", + "dependencies": { + "possible-typed-array-names": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/base-x": { + "version": "3.0.11", + "resolved": "https://registry.npmjs.org/base-x/-/base-x-3.0.11.tgz", + "integrity": "sha512-xz7wQ8xDhdyP7tQxwdteLYeFfS68tSMNCZ/Y37WJ4bhGfKPpqEIlmIyueQHqOyoPhE6xNUqjzRr8ra0eF9VRvA==", + "license": "MIT", + "dependencies": { + "safe-buffer": "^5.0.1" + } + }, + "node_modules/base64-js": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/baseline-browser-mapping": { + "version": "2.11.34", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.34.tgz", + "integrity": "sha512-Aqr8mA1kIvyJ3UY5YAY7ib8LSo1DmDMbMnVqGPtsKW1LxaFQFwn9Eb3yvq2fUKJsRvaXjnAV7R5osqETapzNiA==", + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/big.js": { + "version": "5.2.2", + "resolved": "https://registry.npmjs.org/big.js/-/big.js-5.2.2.tgz", + "integrity": "sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/binary-extensions": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz", + "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/bip32": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/bip32/-/bip32-4.0.0.tgz", + "integrity": "sha512-aOGy88DDlVUhspIXJN+dVEtclhIsfAUppD43V0j40cPTld3pv/0X/MlrZSZ6jowIaQQzFwP8M6rFU2z2mVYjDQ==", + "license": "MIT", + "dependencies": { + "@noble/hashes": "^1.2.0", + "@scure/base": "^1.1.1", + "typeforce": "^1.11.5", + "wif": "^2.0.6" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/bip39": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bip39/-/bip39-3.1.2.tgz", + "integrity": "sha512-inxKLEH+Weos8f5rBYNKuOrpOIcNWtKnrLur9x72s4Cb8w4Mm0jJktUPkev7+1pQuivxFqkiut9+AcrwunLHxA==", + "license": "ISC", + "dependencies": { + "@noble/hashes": "^1.2.0" + } + }, + "node_modules/bn.js": { + "version": "4.12.5", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.5.tgz", + "integrity": "sha512-3aRg6/JxfffFD+OlOjOFR3Vo79l39ooBTFucxx+MT3dhCtzn3EmiUPQo+6/OZuI2jbXi3YKgmiTFBgChQMwIRQ==", + "license": "MIT" + }, + "node_modules/body-parser": { + "version": "1.20.9", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.9.tgz", + "integrity": "sha512-FISIQxV5u91Y9gvuFq3q/tA/qTqLJn3AhRcEvyozyhJTh5OBFFtv827AdHU7Rbyct4r+Ba1/99oFa1Y3yuFsdw==", + "license": "MIT", + "dependencies": { + "bytes": "~3.1.2", + "content-type": "~1.0.5", + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "~1.2.0", + "http-errors": "~2.0.1", + "iconv-lite": "~0.4.24", + "on-finished": "~2.4.1", + "qs": "~6.16.0", + "raw-body": "~2.5.3", + "type-is": "~1.6.18", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/body-parser/node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/boolbase": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz", + "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==", + "license": "ISC" + }, + "node_modules/bootstrap": { + "version": "3.4.1", + "resolved": "https://registry.npmjs.org/bootstrap/-/bootstrap-3.4.1.tgz", + "integrity": "sha512-yN5oZVmRCwe5aKwzRj6736nSmKDX7pLYwsXiCj/EYmo16hODaBiT4En5btW/jhBF/seV+XMx3aYwukYC3A49DA==", + "deprecated": "This version of Bootstrap is no longer supported. Please upgrade to the latest version.", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/bowser": { + "version": "2.15.0", + "resolved": "https://registry.npmjs.org/bowser/-/bowser-2.15.0.tgz", + "integrity": "sha512-xic6KSZglg/I4ymp45fdM4GWfYpBK79Fxd/TOvJktlaPgQqqDxvmGwOPZl2V0dyeS3Lj5c180bLhXF43iyAjZQ==", + "license": "MIT", + "optional": true + }, + "node_modules/brace-expansion": { + "version": "1.1.21", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.21.tgz", + "integrity": "sha512-9zeA+KLZNNzglF2TPKRQEDyx6Yby7daAkuy8MiPzpXPsYDWi/DRM8jmwUDxokQjYqBpv5DgPiwD4h4ZZSy1Ujw==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/braces": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "fill-range": "^7.1.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/brorand": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", + "integrity": "sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==", + "license": "MIT" + }, + "node_modules/browserslist": { + "version": "4.29.5", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.29.5.tgz", + "integrity": "sha512-khTmKu5NGYTotqcYo8Bew2k4RAE9PuXRSFRXG2lQBrCEQHyeQ/vX6gKMxfokwywBsLiXZMnHsmWMG1pnO8J7uQ==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "baseline-browser-mapping": "^2.11.33", + "caniuse-lite": "^1.0.30001819", + "electron-to-chromium": "^1.5.464", + "node-releases": "^2.0.60", + "update-browserslist-db": "^1.3.4" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/bs58": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/bs58/-/bs58-6.0.0.tgz", + "integrity": "sha512-PD0wEnEYg6ijszw/u8s+iI3H17cTymlrwkKhDhPZq+Sokl3AU4htyBFTjAeNAlCCmg0f53g6ih3jATyCKftTfw==", + "license": "MIT", + "dependencies": { + "base-x": "^5.0.0" + } + }, + "node_modules/bs58/node_modules/base-x": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/base-x/-/base-x-5.0.1.tgz", + "integrity": "sha512-M7uio8Zt++eg3jPj+rHMfCC+IuygQHHCOU+IYsVtik6FWjuYpVt/+MRKcgsAMHh8mMFAwnB+Bs+mTrFiXjMzKg==", + "license": "MIT" + }, + "node_modules/bs58check": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/bs58check/-/bs58check-2.1.2.tgz", + "integrity": "sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA==", + "license": "MIT", + "dependencies": { + "bs58": "^4.0.0", + "create-hash": "^1.1.0", + "safe-buffer": "^5.1.2" + } + }, + "node_modules/bs58check/node_modules/bs58": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/bs58/-/bs58-4.0.1.tgz", + "integrity": "sha512-Ok3Wdf5vOIlBrgCvTq96gBkJw+JUEzdBgyaza5HLtPm7yTHkjRy8+JzNyHF7BHa0bNWOQIp3m5YF0nnFcOIKLw==", + "license": "MIT", + "dependencies": { + "base-x": "^3.0.2" + } + }, + "node_modules/bson": { + "version": "4.7.2", + "resolved": "https://registry.npmjs.org/bson/-/bson-4.7.2.tgz", + "integrity": "sha512-Ry9wCtIZ5kGqkJoi6aD8KjxFZEx78guTQDnpXWiNthsxzrxAK/i8E6pCHAIZTbaEFWcOCvbecMukfK7XUvyLpQ==", + "license": "Apache-2.0", + "dependencies": { + "buffer": "^5.6.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/buffer": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz", + "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "base64-js": "^1.3.1", + "ieee754": "^1.1.13" + } + }, + "node_modules/buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", + "license": "MIT" + }, + "node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/cacheable-lookup": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-5.0.4.tgz", + "integrity": "sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==", + "license": "MIT", + "engines": { + "node": ">=10.6.0" + } + }, + "node_modules/cacheable-request": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-7.0.4.tgz", + "integrity": "sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg==", + "license": "MIT", + "dependencies": { + "clone-response": "^1.0.2", + "get-stream": "^5.1.0", + "http-cache-semantics": "^4.0.0", + "keyv": "^4.0.0", + "lowercase-keys": "^2.0.0", + "normalize-url": "^6.0.1", + "responselike": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/call-bind": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.9.tgz", + "integrity": "sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "get-intrinsic": "^1.3.0", + "set-function-length": "^1.2.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/call-bound": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", + "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "get-intrinsic": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001819", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001819.tgz", + "integrity": "sha512-LFUqIIAwpzsIuevnKnsR9qnStBcgzPShTX61lBwN9uFkkf8o8zLiebEjbW8AYtZiF+1YKDWfdt/pWDtMuG8Xwg==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/chance": { + "version": "1.1.13", + "resolved": "https://registry.npmjs.org/chance/-/chance-1.1.13.tgz", + "integrity": "sha512-V6lQCljcLznE7tUYUM9EOAnnKXbctE6j/rdQkYOHIWbfGQbrzTsAXNW9CdU5XCo4ArXQCj/rb6HgxPlmGJcaUg==", + "dev": true, + "license": "MIT" + }, + "node_modules/chardet": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/chardet/-/chardet-1.6.0.tgz", + "integrity": "sha512-+QOTw3otC4+FxdjK9RopGpNOglADbr4WPFi0SonkO99JbpkTPbMxmdm4NenhF5Zs+4gPXLI1+y2uazws5TMe8w==", + "license": "MIT" + }, + "node_modules/cheerio": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.2.0.tgz", + "integrity": "sha512-WDrybc/gKFpTYQutKIK6UvfcuxijIZfMfXaYm8NMsPQxSYvf+13fXUJ4rztGGbJcBQ/GF55gvrZ0Bc0bj/mqvg==", + "license": "MIT", + "dependencies": { + "cheerio-select": "^2.1.0", + "dom-serializer": "^2.0.0", + "domhandler": "^5.0.3", + "domutils": "^3.2.2", + "encoding-sniffer": "^0.2.1", + "htmlparser2": "^10.1.0", + "parse5": "^7.3.0", + "parse5-htmlparser2-tree-adapter": "^7.1.0", + "parse5-parser-stream": "^7.1.2", + "undici": "^7.19.0", + "whatwg-mimetype": "^4.0.0" + }, + "engines": { + "node": ">=20.18.1" + }, + "funding": { + "url": "https://github.com/cheeriojs/cheerio?sponsor=1" + } + }, + "node_modules/cheerio-select": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/cheerio-select/-/cheerio-select-2.1.0.tgz", + "integrity": "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==", + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "^1.0.0", + "css-select": "^5.1.0", + "css-what": "^6.1.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3", + "domutils": "^3.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/chokidar": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz", + "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "anymatch": "~3.1.2", + "braces": "~3.0.2", + "glob-parent": "~5.1.2", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.6.0" + }, + "engines": { + "node": ">= 8.10.0" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/chokidar/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/chrome-trace-event": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.4.tgz", + "integrity": "sha512-rNjApaLzuwaOTjCiT8lSDdGN1APCiqkChLMJxJPWLunPAt5fy8xgU9/jNOchV84wfIxrA0lRQB7oCT8jrn/wrQ==", + "license": "MIT", + "engines": { + "node": ">=6.0" + } + }, + "node_modules/cipher-base": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.7.tgz", + "integrity": "sha512-Mz9QMT5fJe7bKI7MH31UilT5cEK5EHHRCccw/YRFsRY47AuNgaV6HY3rscp0/I4Q+tTW/5zoqpSeRRI54TkDWA==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.4", + "safe-buffer": "^5.2.1", + "to-buffer": "^1.2.2" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/clone-deep": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/clone-deep/-/clone-deep-4.0.1.tgz", + "integrity": "sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==", + "license": "MIT", + "dependencies": { + "is-plain-object": "^2.0.4", + "kind-of": "^6.0.2", + "shallow-clone": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/clone-response": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/clone-response/-/clone-response-1.0.3.tgz", + "integrity": "sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA==", + "license": "MIT", + "dependencies": { + "mimic-response": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/color": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/color/-/color-5.0.3.tgz", + "integrity": "sha512-ezmVcLR3xAVp8kYOm4GS45ZLLgIE6SPAFoduLr6hTDajwb3KZ2F46gulK3XpcwRFb5KKGCSezCBAY4Dw4HsyXA==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^3.1.3", + "color-string": "^2.1.3" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "license": "MIT" + }, + "node_modules/color-string": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/color-string/-/color-string-2.1.4.tgz", + "integrity": "sha512-Bb6Cq8oq0IjDOe8wJmi4JeNn763Xs9cfrBcaylK1tPypWzyoy2G3l90v9k64kjphl/ZJjPIShFztenRomi8WTg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "^2.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/color-string/node_modules/color-name": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-2.1.1.tgz", + "integrity": "sha512-p2FdgwVx1a9yWBHP2wI0VgShkDpgN4kZISkxdNipGBJWpa5G6b04OINlVWCyJj0JmfvcPrgqt95E9k8yvaOJFg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.20" + } + }, + "node_modules/color/node_modules/color-convert": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-3.1.3.tgz", + "integrity": "sha512-fasDH2ont2GqF5HpyO4w0+BcewlhHEZOFn9c1ckZdHpJ56Qb7MHhH/IcJZbBGgvdtwdwNbLvxiBEdg336iA9Sg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "^2.0.0" + }, + "engines": { + "node": ">=14.6" + } + }, + "node_modules/color/node_modules/color-name": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-2.1.1.tgz", + "integrity": "sha512-p2FdgwVx1a9yWBHP2wI0VgShkDpgN4kZISkxdNipGBJWpa5G6b04OINlVWCyJj0JmfvcPrgqt95E9k8yvaOJFg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.20" + } + }, + "node_modules/colorette": { + "version": "2.0.20", + "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz", + "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==", + "dev": true, + "license": "MIT" + }, + "node_modules/commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", + "license": "MIT" + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true, + "license": "MIT" + }, + "node_modules/content-disposition": { + "version": "0.5.4", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz", + "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==", + "license": "MIT", + "dependencies": { + "safe-buffer": "5.2.1" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/content-type": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", + "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", + "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie-signature": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.7.tgz", + "integrity": "sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==", + "license": "MIT" + }, + "node_modules/core-util-is": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz", + "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==", + "license": "MIT" + }, + "node_modules/cors": { + "version": "2.8.6", + "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.6.tgz", + "integrity": "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==", + "license": "MIT", + "dependencies": { + "object-assign": "^4", + "vary": "^1" + }, + "engines": { + "node": ">= 0.10" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/create-hash": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", + "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", + "license": "MIT", + "dependencies": { + "cipher-base": "^1.0.1", + "inherits": "^2.0.1", + "md5.js": "^1.3.4", + "ripemd160": "^2.0.1", + "sha.js": "^2.4.0" + } + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/css-select": { + "version": "5.2.2", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.2.2.tgz", + "integrity": "sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==", + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "^1.0.0", + "css-what": "^6.1.0", + "domhandler": "^5.0.2", + "domutils": "^3.0.1", + "nth-check": "^2.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/css-what": { + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.2.2.tgz", + "integrity": "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==", + "license": "BSD-2-Clause", + "engines": { + "node": ">= 6" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/date-format": { + "version": "4.0.14", + "resolved": "https://registry.npmjs.org/date-format/-/date-format-4.0.14.tgz", + "integrity": "sha512-39BOQLs9ZjKh0/patS9nrT8wc3ioX3/eA/zgbKNopnF2wCqJEoxywwwElATYvRsXdnOxA/OQeQoFZ3rFjVajhg==", + "license": "MIT", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/decay": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/decay/-/decay-1.0.12.tgz", + "integrity": "sha512-DRpSWu29m3TXVVrNhTjfHKwIkrcNECJrTzdDACA64A78qZV9jUqyhBG2DA/ov0UZgWss04QPPaVevyPeu7fvNA==", + "license": "MIT" + }, + "node_modules/decompress-response": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz", + "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==", + "license": "MIT", + "dependencies": { + "mimic-response": "^3.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/decompress-response/node_modules/mimic-response": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz", + "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/defer-to-connect": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz", + "integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==", + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/define-data-property": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz", + "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==", + "license": "MIT", + "dependencies": { + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "gopd": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/destroy": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz", + "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==", + "license": "MIT", + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/detect-libc": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz", + "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==", + "license": "Apache-2.0", + "engines": { + "node": ">=8" + } + }, + "node_modules/diff-match-patch": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/diff-match-patch/-/diff-match-patch-1.0.5.tgz", + "integrity": "sha512-IayShXAgj/QMXgB0IWmKx+rOPuGMhqm5w6jvFxmVenXKIzRqTAAsbBPT3kWQeGANj3jGgvcvv4yK6SxqYmikgw==", + "dev": true, + "license": "Apache-2.0" + }, + "node_modules/doctrine": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", + "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "esutils": "^2.0.2" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/dom-serializer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz", + "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==", + "license": "MIT", + "dependencies": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.2", + "entities": "^4.2.0" + }, + "funding": { + "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1" + } + }, + "node_modules/dom-serializer/node_modules/entities": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz", + "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/domelementtype": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz", + "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ], + "license": "BSD-2-Clause" + }, + "node_modules/domhandler": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz", + "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==", + "license": "BSD-2-Clause", + "dependencies": { + "domelementtype": "^2.3.0" + }, + "engines": { + "node": ">= 4" + }, + "funding": { + "url": "https://github.com/fb55/domhandler?sponsor=1" + } + }, + "node_modules/domutils": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.2.tgz", + "integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==", + "license": "BSD-2-Clause", + "dependencies": { + "dom-serializer": "^2.0.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3" + }, + "funding": { + "url": "https://github.com/fb55/domutils?sponsor=1" + } + }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==", + "license": "MIT" + }, + "node_modules/electron-to-chromium": { + "version": "1.5.467", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.467.tgz", + "integrity": "sha512-Nw9X371rtZmYcBSnEijnCDONILjs93biCZO34juC7MBOmK8E+GFnyD4T/WvyrlJkppul7oxg6TwvtKst9SODTw==", + "license": "ISC" + }, + "node_modules/elliptic": { + "version": "6.6.1", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.6.1.tgz", + "integrity": "sha512-RaddvvMatK2LJHqFJ+YA4WysVN5Ita9E35botqIYspQ4TkRAlCicdzKOjlyv/1Za5RyTNn7di//eEV0uTAfe3g==", + "license": "MIT", + "dependencies": { + "bn.js": "^4.11.9", + "brorand": "^1.1.0", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.1", + "inherits": "^2.0.4", + "minimalistic-assert": "^1.0.1", + "minimalistic-crypto-utils": "^1.0.1" + } + }, + "node_modules/emojis-list": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/emojis-list/-/emojis-list-3.0.0.tgz", + "integrity": "sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==", + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/enabled": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/enabled/-/enabled-2.0.0.tgz", + "integrity": "sha512-AKrN98kuwOzMIdAizXGI86UFBoo26CL21UM763y1h/GMSJ4/OHU9k2YlsmBpyScFo/wbLzWQJBMCW4+IO3/+OQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/encoding-sniffer": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/encoding-sniffer/-/encoding-sniffer-0.2.1.tgz", + "integrity": "sha512-5gvq20T6vfpekVtqrYQsSCFZ1wEg5+wW0/QaZMWkFr6BqD3NfKs0rLCx4rrVlSWJeZb5NBJgVLswK/w2MWU+Gw==", + "license": "MIT", + "dependencies": { + "iconv-lite": "^0.6.3", + "whatwg-encoding": "^3.1.1" + }, + "funding": { + "url": "https://github.com/fb55/encoding-sniffer?sponsor=1" + } + }, + "node_modules/end-of-stream": { + "version": "1.4.5", + "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz", + "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==", + "license": "MIT", + "dependencies": { + "once": "^1.4.0" + } + }, + "node_modules/enhanced-resolve": { + "version": "5.26.0", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.26.0.tgz", + "integrity": "sha512-9vhedylFonb2YGogzUKX6+Ja72gOJbN1QHAqdrvqLwhdl/QWbKopzoUC9EbQNVsAns/bx/4uyqalrQAoy1IByw==", + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.4", + "tapable": "^2.3.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/entities": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-2.1.0.tgz", + "integrity": "sha512-hCx1oky9PFrJ611mf0ifBLBRW8lUUVRlFolb5gWRfIELabBlbp9xZvrqZLZAs+NxFnbfQoeGd8wDkygjg7U85w==", + "dev": true, + "license": "BSD-2-Clause", + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/envinfo": { + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/envinfo/-/envinfo-7.21.0.tgz", + "integrity": "sha512-Lw7I8Zp5YKHFCXL7+Dz95g4CcbMEpgvqZNNq3AmlT5XAV6CgAAk6gyAMqn2zjw08K9BHfcNuKrMiCPLByGafow==", + "dev": true, + "license": "MIT", + "bin": { + "envinfo": "dist/cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/error-ex": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.4.tgz", + "integrity": "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==", + "license": "MIT", + "dependencies": { + "is-arrayish": "^0.2.1" + } + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-module-lexer": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.2.tgz", + "integrity": "sha512-poHGpORABojJJucnV9KbOavETW8lBVnphkW77ER5/BQ5Fz7oXSoCNek7IH3vR5nRjdsEz926ibFYX8KtLQmdyw==", + "license": "MIT" + }, + "node_modules/es-object-atoms": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz", + "integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/esbuild": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz", + "integrity": "sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==", + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.28.2", + "@esbuild/android-arm": "0.28.2", + "@esbuild/android-arm64": "0.28.2", + "@esbuild/android-x64": "0.28.2", + "@esbuild/darwin-arm64": "0.28.2", + "@esbuild/darwin-x64": "0.28.2", + "@esbuild/freebsd-arm64": "0.28.2", + "@esbuild/freebsd-x64": "0.28.2", + "@esbuild/linux-arm": "0.28.2", + "@esbuild/linux-arm64": "0.28.2", + "@esbuild/linux-ia32": "0.28.2", + "@esbuild/linux-loong64": "0.28.2", + "@esbuild/linux-mips64el": "0.28.2", + "@esbuild/linux-ppc64": "0.28.2", + "@esbuild/linux-riscv64": "0.28.2", + "@esbuild/linux-s390x": "0.28.2", + "@esbuild/linux-x64": "0.28.2", + "@esbuild/netbsd-arm64": "0.28.2", + "@esbuild/netbsd-x64": "0.28.2", + "@esbuild/openbsd-arm64": "0.28.2", + "@esbuild/openbsd-x64": "0.28.2", + "@esbuild/openharmony-arm64": "0.28.2", + "@esbuild/sunos-x64": "0.28.2", + "@esbuild/win32-arm64": "0.28.2", + "@esbuild/win32-ia32": "0.28.2", + "@esbuild/win32-x64": "0.28.2" + } + }, + "node_modules/esbuild-loader": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/esbuild-loader/-/esbuild-loader-4.5.0.tgz", + "integrity": "sha512-rVYe97IN1+VoealVHQ3STEPbfTm+vvPk7AZPrL53Pt6JUGBhHTnIqyaow7EveMFlmQ2A1bLp7q19sP4PppaCDQ==", + "license": "MIT", + "dependencies": { + "esbuild": "^0.28.1", + "get-tsconfig": "^4.10.1", + "loader-utils": "^2.0.4", + "webpack-sources": "^3.3.4" + }, + "funding": { + "url": "https://github.com/privatenumber/esbuild-loader?sponsor=1" + }, + "peerDependencies": { + "webpack": "^4.40.0 || ^5.0.0" + } + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==", + "license": "MIT" + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint": { + "version": "8.57.1", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.57.1.tgz", + "integrity": "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==", + "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.2.0", + "@eslint-community/regexpp": "^4.6.1", + "@eslint/eslintrc": "^2.1.4", + "@eslint/js": "8.57.1", + "@humanwhocodes/config-array": "^0.13.0", + "@humanwhocodes/module-importer": "^1.0.1", + "@nodelib/fs.walk": "^1.2.8", + "@ungap/structured-clone": "^1.2.0", + "ajv": "^6.12.4", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.2", + "debug": "^4.3.2", + "doctrine": "^3.0.0", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^7.2.2", + "eslint-visitor-keys": "^3.4.3", + "espree": "^9.6.1", + "esquery": "^1.4.2", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^6.0.1", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "globals": "^13.19.0", + "graphemer": "^1.4.0", + "ignore": "^5.2.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "is-path-inside": "^3.0.3", + "js-yaml": "^4.1.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "levn": "^0.4.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.2", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3", + "strip-ansi": "^6.0.1", + "text-table": "^0.2.0" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-scope": { + "version": "7.2.2", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz", + "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", + "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/eslint/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/espree": { + "version": "9.6.1", + "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz", + "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "acorn": "^8.9.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^3.4.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esquery": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz", + "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "estraverse": "^5.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/events": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz", + "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==", + "license": "MIT", + "engines": { + "node": ">=0.8.x" + } + }, + "node_modules/expose-loader": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/expose-loader/-/expose-loader-4.1.0.tgz", + "integrity": "sha512-oLAesnzerwDGGADzBMnu0LPqqnlVz6e2V9lTa+/4X6VeW9W93x/nJpw05WBrcIdbqXm/EdnEQpiVDFFiQXuNfg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 14.15.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.0.0" + } + }, + "node_modules/express": { + "version": "4.22.3", + "resolved": "https://registry.npmjs.org/express/-/express-4.22.3.tgz", + "integrity": "sha512-Bdcs4+3qlpVlx2NRn6fgX2Ue2/gGRaPeawebgclM0ERSCqDpA+owF1fdPwjJUTAJWMTuAaxjDf+hzb0/4eKvvw==", + "license": "MIT", + "dependencies": { + "accepts": "~1.3.8", + "array-flatten": "1.1.1", + "body-parser": "~1.20.5", + "content-disposition": "~0.5.4", + "content-type": "~1.0.4", + "cookie": "~0.7.1", + "cookie-signature": "~1.0.6", + "debug": "2.6.9", + "depd": "2.0.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "~1.3.1", + "fresh": "~0.5.2", + "http-errors": "~2.0.0", + "merge-descriptors": "1.0.3", + "methods": "~1.1.2", + "on-finished": "~2.4.1", + "parseurl": "~1.3.3", + "path-to-regexp": "~0.1.13", + "proxy-addr": "~2.0.7", + "qs": "~6.16.0", + "range-parser": "~1.2.1", + "safe-buffer": "5.2.1", + "send": "~0.19.0", + "serve-static": "~1.16.2", + "setprototypeof": "1.2.0", + "statuses": "~2.0.1", + "type-is": "~1.6.18", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/express-rate-limit": { + "version": "8.7.1", + "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-8.7.1.tgz", + "integrity": "sha512-2FXbqkygil3mZiXzEtM0IjE/UBmBNot0J1GEVrJT4JbrvwOSoEtqtO+wHbiMQELWe1eNvHoYRg2dkjOid+6JkA==", + "license": "MIT", + "dependencies": { + "debug": "^4.4.3", + "ip-address": "^10.2.0" + }, + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://github.com/sponsors/express-rate-limit" + }, + "peerDependencies": { + "express": ">= 4.11" + } + }, + "node_modules/express-rate-limit/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/express-rate-limit/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "license": "MIT" + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-uri": { + "version": "3.1.9", + "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.9.tgz", + "integrity": "sha512-hS/0Wt3Ya043oKXs0sIxrMpKQITXhMLIrVAKKXi4gozGC9v7YRWVnXIZzjNPTO02M9BdxLCWqK1yRXgNziVyJQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fastify" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/fastify" + } + ], + "license": "BSD-3-Clause" + }, + "node_modules/fastest-levenshtein": { + "version": "1.0.16", + "resolved": "https://registry.npmjs.org/fastest-levenshtein/-/fastest-levenshtein-1.0.16.tgz", + "integrity": "sha512-eRnCtTTtGZFpQCwhJiUOuxPQWRXVKYDn0b2PeHfXL6/Zi53SLAzAHfVhVWK2AryC/WH05kGfxhFIPvTF0SXQzg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4.9.1" + } + }, + "node_modules/fastq": { + "version": "1.20.3", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.3.tgz", + "integrity": "sha512-XKv5nnLs6nLF71NgiKJLIZFLkPyIEuOselLG7ujZnGrRfQK8HpvY+WqKhAJUAdLomwVHErVS4LfxFlPq0/FTAw==", + "dev": true, + "license": "ISC", + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/fecha": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/fecha/-/fecha-4.2.3.tgz", + "integrity": "sha512-OP2IUU6HeYKJi3i0z4A19kHMQoLVs4Hc+DPqqxI2h/DPZHTm/vjsfC6P0b4jCMy14XizLBqvndQ+UilD7707Jw==", + "dev": true, + "license": "MIT" + }, + "node_modules/figures": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz", + "integrity": "sha512-Oa2M9atig69ZkfwiApY8F2Yy+tzMbazyvqv21R0NsSC8floSOC09BbT1ITWAdoMGQvJ/aZnR1KMwdx9tvHnTNA==", + "license": "MIT", + "dependencies": { + "escape-string-regexp": "^1.0.5" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/figures/node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "license": "MIT", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/file-entry-cache": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz", + "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==", + "dev": true, + "license": "MIT", + "dependencies": { + "flat-cache": "^3.0.4" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/fill-range": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", + "dev": true, + "license": "MIT", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/finalhandler": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", + "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "on-finished": "~2.4.1", + "parseurl": "~1.3.3", + "statuses": "~2.0.2", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", + "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==", + "dev": true, + "license": "BSD-3-Clause", + "bin": { + "flat": "cli.js" + } + }, + "node_modules/flat-cache": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz", + "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "flatted": "^3.2.9", + "keyv": "^4.5.3", + "rimraf": "^3.0.2" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/flatted": { + "version": "3.4.4", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.4.tgz", + "integrity": "sha512-5+ybhBZANEJxaH3X5evAFatUxLfEHSr7n6kYJ+1Qd0mUqr4eu9gIf6GDbWHf8RJijHrjjO8G+la14SlL2SeS1Q==", + "license": "ISC" + }, + "node_modules/fn.name": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fn.name/-/fn.name-1.1.0.tgz", + "integrity": "sha512-GRnmB5gPyJpAhTQdSZTSp9uaPSvl09KoYcMQtsB9rQoOmzs9dH6ffeccH+Z+cv6P68Hu5bC6JjRh4Ah/mHSNRw==", + "dev": true, + "license": "MIT" + }, + "node_modules/for-each": { + "version": "0.3.5", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz", + "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==", + "license": "MIT", + "dependencies": { + "is-callable": "^1.2.7" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", + "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fresh": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz", + "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fs-extra": { + "version": "11.4.1", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.4.1.tgz", + "integrity": "sha512-KYAb4c9BJQI6QqGKthV68OHe0badztdXJWKo0WtBA9IuCFPTKvE5ZdUBglP833aMjhaSPNO4A5j/EkzZtGlKjA==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=14.14" + } + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "dev": true, + "license": "ISC" + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-intrinsic": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/get-stream": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz", + "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==", + "license": "MIT", + "dependencies": { + "pump": "^3.0.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/get-tsconfig": { + "version": "4.14.3", + "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.14.3.tgz", + "integrity": "sha512-++QEw4DIY7WGoukz+/+A/8dGYPT9l9yIadnmSgZ8Rjr3YVSVDipQSO9CdnJo9ePqFqUUqh+wk9uIaoiAwsiPkA==", + "license": "MIT", + "dependencies": { + "resolve-pkg-maps": "^1.0.0" + }, + "funding": { + "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" + } + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me", + "dev": true, + "license": "ISC", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/globals": { + "version": "13.24.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", + "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "type-fest": "^0.20.2" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/got": { + "version": "11.8.6", + "resolved": "https://registry.npmjs.org/got/-/got-11.8.6.tgz", + "integrity": "sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g==", + "license": "MIT", + "dependencies": { + "@sindresorhus/is": "^4.0.0", + "@szmarczak/http-timer": "^4.0.5", + "@types/cacheable-request": "^6.0.1", + "@types/responselike": "^1.0.0", + "cacheable-lookup": "^5.0.3", + "cacheable-request": "^7.0.2", + "decompress-response": "^6.0.0", + "http2-wrapper": "^1.0.0-beta.5.2", + "lowercase-keys": "^2.0.0", + "p-cancelable": "^2.0.0", + "responselike": "^2.0.0" + }, + "engines": { + "node": ">=10.19.0" + }, + "funding": { + "url": "https://github.com/sindresorhus/got?sponsor=1" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "license": "ISC" + }, + "node_modules/graphemer": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz", + "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==", + "dev": true, + "license": "MIT" + }, + "node_modules/growint": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/growint/-/growint-1.0.1.tgz", + "integrity": "sha512-RBsLnzK+oc9GWqm8Ip+KoExzkCZwg/L7O8/s04cChFxkZf0MP/EclD3iHhM1S0CqoagFGQOFI+EQLdiDYgC5dw==", + "license": "MIT" + }, + "node_modules/handlebars": { + "version": "4.7.10", + "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.7.10.tgz", + "integrity": "sha512-P5VJMVM7qgBn6vjXMw8WG9uVI+ncf2pi72j4de4yz5ZULLj2RGqLYaKOYGsgyrViQ0tePOVlN1tDCCXXtFqXKg==", + "dev": true, + "license": "MIT", + "dependencies": { + "minimist": "^1.2.8", + "neo-async": "^2.6.2", + "source-map": "^0.6.1", + "wordwrap": "^1.0.0" + }, + "bin": { + "handlebars": "bin/handlebars" + }, + "engines": { + "node": ">=0.4.7" + }, + "optionalDependencies": { + "uglify-js": "^3.1.4" + } + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/has-property-descriptors": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz", + "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==", + "license": "MIT", + "dependencies": { + "es-define-property": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", + "license": "MIT", + "dependencies": { + "has-symbols": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hash-base": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.1.2.tgz", + "integrity": "sha512-Bb33KbowVTIj5s7Ked1OsqHUeCpz//tPwR+E2zJgJKo9Z5XolZ9b6bdUgjmYlwnWhoOQKoTd1TYToZGn5mAYOg==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.4", + "readable-stream": "^2.3.8", + "safe-buffer": "^5.2.1", + "to-buffer": "^1.2.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/hash-base/node_modules/isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==", + "license": "MIT" + }, + "node_modules/hash-base/node_modules/readable-stream": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz", + "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==", + "license": "MIT", + "dependencies": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" + } + }, + "node_modules/hash-base/node_modules/readable-stream/node_modules/safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "license": "MIT" + }, + "node_modules/hash-base/node_modules/string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "license": "MIT", + "dependencies": { + "safe-buffer": "~5.1.0" + } + }, + "node_modules/hash-base/node_modules/string_decoder/node_modules/safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "license": "MIT" + }, + "node_modules/hash.js": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.7.tgz", + "integrity": "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.3", + "minimalistic-assert": "^1.0.1" + } + }, + "node_modules/hasown": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz", + "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/hmac-drbg": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", + "integrity": "sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==", + "license": "MIT", + "dependencies": { + "hash.js": "^1.0.3", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.1" + } + }, + "node_modules/htmlparser2": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-10.1.0.tgz", + "integrity": "sha512-VTZkM9GWRAtEpveh7MSF6SjjrpNVNNVJfFup7xTY3UpFtm67foy9HDVXneLtFVt4pMz5kZtgNcvCniNFb1hlEQ==", + "funding": [ + "https://github.com/fb55/htmlparser2?sponsor=1", + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ], + "license": "MIT", + "dependencies": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3", + "domutils": "^3.2.2", + "entities": "^7.0.1" + } + }, + "node_modules/htmlparser2/node_modules/entities": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz", + "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/http-cache-semantics": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.3.0.tgz", + "integrity": "sha512-M5t5LlJpS1UHMjvwRQVdFHvPISGeLAxNcrWuJkeGh0KxsqCHZ1O3NXZU/8x7cD0BDcGW8kapxMKTvwlqrNkHkA==", + "license": "BSD-2-Clause" + }, + "node_modules/http-errors": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", + "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", + "license": "MIT", + "dependencies": { + "depd": "~2.0.0", + "inherits": "~2.0.4", + "setprototypeof": "~1.2.0", + "statuses": "~2.0.2", + "toidentifier": "~1.0.1" + }, + "engines": { + "node": ">= 0.8" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/http2-wrapper": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-1.0.3.tgz", + "integrity": "sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==", + "license": "MIT", + "dependencies": { + "quick-lru": "^5.1.1", + "resolve-alpn": "^1.0.0" + }, + "engines": { + "node": ">=10.19.0" + } + }, + "node_modules/iconv-lite": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", + "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/ieee754": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", + "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "BSD-3-Clause" + }, + "node_modules/ignore": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/ignore-by-default": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/ignore-by-default/-/ignore-by-default-1.0.1.tgz", + "integrity": "sha512-Ius2VYcGNk7T90CppJqcIkS5ooHUZyIQK+ClZfMfMNFEF9VSE73Fq+906u/CWu92x4gzZMWOwfFYckPObzdEbA==", + "dev": true, + "license": "ISC" + }, + "node_modules/import-fresh": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", + "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/import-local": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.2.0.tgz", + "integrity": "sha512-2SPlun1JUPWoM6t3F0dw0FkCF/jWY8kttcY4f599GLTSjh2OCuuhdTkJQsEcZzBqbXZGKMK2OqW1oZsjtf/gQA==", + "dev": true, + "license": "MIT", + "dependencies": { + "pkg-dir": "^4.2.0", + "resolve-cwd": "^3.0.0" + }, + "bin": { + "import-local-fixture": "fixtures/cli.js" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.", + "dev": true, + "license": "ISC", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "license": "ISC" + }, + "node_modules/interpret": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/interpret/-/interpret-2.2.0.tgz", + "integrity": "sha512-Ju0Bz/cEia55xDwUWEa8+olFpCiQoypjnQySseKtmjNrnps3P+xfpUmGr90T7yjlVJmOtybRvPXhKMbHr+fWnw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/ip-address": { + "version": "10.7.5", + "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.7.5.tgz", + "integrity": "sha512-t2v0rkILYv9WXmSL7TpAaU3HXgaFYOPUcH3QHgwQ++gpJuH3bqyMy4Fvt/DJCTKwzH3Cf+bAp5W/mFL39KPLzA==", + "license": "MIT", + "engines": { + "node": ">= 12" + } + }, + "node_modules/ipaddr.js": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", + "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", + "license": "MIT" + }, + "node_modules/is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "dev": true, + "license": "MIT", + "dependencies": { + "binary-extensions": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-callable": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", + "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-core-module": { + "version": "2.17.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.17.0.tgz", + "integrity": "sha512-J/vG0zBCbIKOQFfufSwyXdMrsohyJIUNkrnmo6WZGzoM7tr/lsbfW5b2BvisL6zsyMzK9UxV9L6c7AoFbyXHOA==", + "dev": true, + "license": "MIT", + "dependencies": { + "hasown": "^2.0.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-path-inside": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", + "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-plain-object": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", + "license": "MIT", + "dependencies": { + "isobject": "^3.0.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-stream": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", + "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-typed-array": { + "version": "1.1.15", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz", + "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==", + "license": "MIT", + "dependencies": { + "which-typed-array": "^1.1.16" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/isarray": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", + "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==", + "license": "MIT" + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "license": "ISC" + }, + "node_modules/iso8601-duration": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/iso8601-duration/-/iso8601-duration-1.3.0.tgz", + "integrity": "sha512-K4CiUBzo3YeWk76FuET/dQPH03WE04R94feo5TSKQCXpoXQt9E4yx2CnY737QZnSAI3PI4WlKo/zfqizGx52QQ==", + "license": "MIT" + }, + "node_modules/isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/javalon2": { + "version": "1.1.10", + "resolved": "https://registry.npmjs.org/javalon2/-/javalon2-1.1.10.tgz", + "integrity": "sha512-HPKmPpkFcI7fo9rbEvhH6wTlixnwfl/39aED7CNgeab2CUVyFb2s29uoCjOw4A/CSVajz0bMrgWhTFj/HSkCHg==", + "license": "MIT", + "dependencies": { + "@aws-crypto/sha256-browser": "^5.2.0", + "@noble/secp256k1": "^3.2.0", + "bip32": "^4.0.0", + "bip39": "^3.1.0", + "bs58": "^6.0.0", + "buffer": "^6.0.3", + "growint": "^1.0.1", + "js-sha256": "^0.11.0", + "node-fetch": "^2.7.0", + "randombytes": "^2.1.0", + "secp256k1": "^5.0.2", + "stream-browserify": "^3.0.0" + } + }, + "node_modules/javalon2/node_modules/buffer": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz", + "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "base64-js": "^1.3.1", + "ieee754": "^1.2.1" + } + }, + "node_modules/javalon2/node_modules/secp256k1": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/secp256k1/-/secp256k1-5.0.2.tgz", + "integrity": "sha512-HwMOXeWjr1UvBNYt9S+w9bMuuyUOrPFQ8CWd23CGai/8vbgtUKS2ITngFOzMhaPZQAPxTb/f9alLou9mPnNV2Q==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "elliptic": "^6.5.7", + "node-addon-api": "^5.0.0", + "node-gyp-build": "^4.2.0" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/jest-worker": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz", + "integrity": "sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==", + "license": "MIT", + "dependencies": { + "@types/node": "*", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + }, + "engines": { + "node": ">= 10.13.0" + } + }, + "node_modules/jest-worker/node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/joycon": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/joycon/-/joycon-3.1.1.tgz", + "integrity": "sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/jquery": { + "version": "3.7.1", + "resolved": "https://registry.npmjs.org/jquery/-/jquery-3.7.1.tgz", + "integrity": "sha512-m4avr8yL8kmFN8psrbFFFmB/If14iN5o9nw/NgnnM+kybDJpRsAynV2BsfpTYrTRysYUdADVD7CkUUizgkpLfg==", + "dev": true, + "license": "MIT" + }, + "node_modules/js-sha256": { + "version": "0.11.1", + "resolved": "https://registry.npmjs.org/js-sha256/-/js-sha256-0.11.1.tgz", + "integrity": "sha512-o6WSo/LUvY2uC4j7mO50a2ms7E/EAdbP0swigLV+nzHKTTaYnaLIWJ02VdXrsJX0vGedDESQnLsOekr94ryfjg==", + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.2.tgz", + "integrity": "sha512-SFNOvSJ+Dgf/9An904Yx+CgSlIPCkIpao4qo51lpee25TIRejdH3rhR4EZMGoNx3/TP3O+wzWuiTFl4sqbltzA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/puzrin" + }, + { + "type": "github", + "url": "https://github.com/sponsors/nodeca" + } + ], + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/json-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "license": "MIT" + }, + "node_modules/json-parse-better-errors": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz", + "integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==", + "license": "MIT" + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/jsonfile": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz", + "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "license": "MIT", + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "node_modules/kind-of": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", + "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/klaw-sync": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/klaw-sync/-/klaw-sync-6.0.0.tgz", + "integrity": "sha512-nIeuVSzdCCs6TDPTqI8w1Yre34sSq7AkZ4B3sfOBbI2CgVSB4Du4aLQijFU2+lhAFCwt9+42Hel6lQNIv6AntQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.1.11" + } + }, + "node_modules/kuler": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/kuler/-/kuler-2.0.0.tgz", + "integrity": "sha512-Xq9nH7KlWZmXAtodXDDRE7vs6DU1gTU8zYDHDiWLSip45Egwq3plLHzPn27NgvzL2r1LMPC1vdqh98sQxtqj4A==", + "dev": true, + "license": "MIT" + }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/linkify-it": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-3.0.3.tgz", + "integrity": "sha512-ynTsyrFSdE5oZ/O9GEf00kPngmOfVwazR5GKDq6EYfhlpFug3J2zybX56a2PRRpc9P+FuSoGNAwjlbDs9jJBPQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "uc.micro": "^1.0.1" + } + }, + "node_modules/load-json-file": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-4.0.0.tgz", + "integrity": "sha512-Kx8hMakjX03tiGTLAIdJ+lL0htKnXjEZN6hk/tozf/WOuYGdZBJrZ+rCJRbVCugsjB3jMLn9746NsQIf5VjBMw==", + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.1.2", + "parse-json": "^4.0.0", + "pify": "^3.0.0", + "strip-bom": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/loader-utils": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-2.0.4.tgz", + "integrity": "sha512-xXqpXoINfFhgua9xiqD8fPFHgkoq1mmmpE92WlDbm9rNRd/EbRb+Gqf908T2DMfuHjjJlksiK2RbHVOdD/MqSw==", + "license": "MIT", + "dependencies": { + "big.js": "^5.2.2", + "emojis-list": "^3.0.0", + "json5": "^2.1.2" + }, + "engines": { + "node": ">=8.9.0" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash": { + "version": "4.18.1", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz", + "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/log4js": { + "version": "6.9.1", + "resolved": "https://registry.npmjs.org/log4js/-/log4js-6.9.1.tgz", + "integrity": "sha512-1somDdy9sChrr9/f4UlzhdaGfDR2c/SaD2a4T7qEkG4jTS57/B3qmnjLYePwQ8cqWnUHZI0iAKxMBpCZICiZ2g==", + "license": "Apache-2.0", + "dependencies": { + "date-format": "^4.0.14", + "debug": "^4.3.4", + "flatted": "^3.2.7", + "rfdc": "^1.3.0", + "streamroller": "^3.1.5" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/log4js/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/log4js/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/logform": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/logform/-/logform-2.7.0.tgz", + "integrity": "sha512-TFYA4jnP7PVbmlBIfhlSe+WKxs9dklXMTEGcBCIvLhE/Tn3H6Gk1norupVW7m5Cnd4bLcr08AytbyV/xj7f/kQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@colors/colors": "1.6.0", + "@types/triple-beam": "^1.3.2", + "fecha": "^4.2.0", + "ms": "^2.1.1", + "safe-stable-stringify": "^2.3.1", + "triple-beam": "^1.3.0" + }, + "engines": { + "node": ">= 12.0.0" + } + }, + "node_modules/logform/node_modules/@colors/colors": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.6.0.tgz", + "integrity": "sha512-Ir+AOibqzrIsL6ajt3Rz3LskB7OiMVHqltZmspbW/TJuTVuyOMirVqAkjfY6JISiLHgyNqicAC8AyHHGzNd/dA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.1.90" + } + }, + "node_modules/logform/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/lowercase-keys": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-2.0.0.tgz", + "integrity": "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/markdown-it": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/markdown-it/-/markdown-it-12.3.2.tgz", + "integrity": "sha512-TchMembfxfNVpHkbtriWltGWc+m3xszaRD0CZup7GFFhzIgQqxIfn3eGj1yZpfuflzPvfkt611B2Q/Bsk1YnGg==", + "dev": true, + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1", + "entities": "~2.1.0", + "linkify-it": "^3.0.1", + "mdurl": "^1.0.1", + "uc.micro": "^1.0.5" + }, + "bin": { + "markdown-it": "bin/markdown-it.js" + } + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/md5.js": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz", + "integrity": "sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==", + "license": "MIT", + "dependencies": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, + "node_modules/mdurl": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-1.0.1.tgz", + "integrity": "sha512-/sKlQJCBYVY9Ers9hqzKou4H6V5UWc/M59TH2dvkt+84itfnq7uFOMLpOiOS4ujvHP4etln18fmIxA5R5fll0g==", + "dev": true, + "license": "MIT" + }, + "node_modules/media-typer": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", + "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/memory-pager": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/memory-pager/-/memory-pager-1.5.0.tgz", + "integrity": "sha512-ZS4Bp4r/Zoeq6+NLJpP+0Zzm0pR8whtGPf1XExKLJBAczGMnSi3It14OiNCStjQjM6NU1okjQGSxgEZN8eBYKg==", + "license": "MIT", + "optional": true + }, + "node_modules/merge-descriptors": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", + "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/merge-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", + "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", + "license": "MIT" + }, + "node_modules/methods": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz", + "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "license": "MIT", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mimic-response": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz", + "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/minimalistic-assert": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", + "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==", + "license": "ISC" + }, + "node_modules/minimalistic-crypto-utils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", + "integrity": "sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg==", + "license": "MIT" + }, + "node_modules/minimatch": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz", + "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/minimizer-webpack-plugin": { + "version": "5.13.1", + "resolved": "https://registry.npmjs.org/minimizer-webpack-plugin/-/minimizer-webpack-plugin-5.13.1.tgz", + "integrity": "sha512-1mhAfvachWYYOm8tpmany5NLuvP+F2wxZWBSX8DC0uFS2wJpM9q3rWgN9wBooAH9d5V12wX0BjyJe4fMjHMarQ==", + "license": "MIT", + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.31", + "jest-worker": "^27.4.5", + "schema-utils": "^4.6.0", + "terser": "^5.51.0" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.1.0" + }, + "peerDependenciesMeta": { + "@minify-html/node": { + "optional": true + }, + "@napi-rs/image": { + "optional": true + }, + "@swc/core": { + "optional": true + }, + "@swc/css": { + "optional": true + }, + "@swc/html": { + "optional": true + }, + "clean-css": { + "optional": true + }, + "cssnano": { + "optional": true + }, + "csso": { + "optional": true + }, + "esbuild": { + "optional": true + }, + "html-minifier-terser": { + "optional": true + }, + "imagemin": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "postcss": { + "optional": true + }, + "sharp": { + "optional": true + }, + "svgo": { + "optional": true + }, + "uglify-js": { + "optional": true + } + } + }, + "node_modules/mongodb": { + "version": "4.17.2", + "resolved": "https://registry.npmjs.org/mongodb/-/mongodb-4.17.2.tgz", + "integrity": "sha512-mLV7SEiov2LHleRJPMPrK2PMyhXFZt2UQLC4VD4pnth3jMjYKHhtqfwwkkvS/NXuo/Fp3vbhaNcXrIDaLRb9Tg==", + "license": "Apache-2.0", + "dependencies": { + "bson": "^4.7.2", + "mongodb-connection-string-url": "^2.6.0", + "socks": "^2.7.1" + }, + "engines": { + "node": ">=12.9.0" + }, + "optionalDependencies": { + "@aws-sdk/credential-providers": "^3.186.0", + "@mongodb-js/saslprep": "^1.1.0" + } + }, + "node_modules/mongodb-connection-string-url": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/mongodb-connection-string-url/-/mongodb-connection-string-url-2.6.0.tgz", + "integrity": "sha512-WvTZlI9ab0QYtTYnuMLgobULWhokRjtC7db9LtcVfJ+Hsnyr5eo6ZtNAt3Ly24XZScGMelOcGtm7lSn0332tPQ==", + "license": "Apache-2.0", + "dependencies": { + "@types/whatwg-url": "^8.2.1", + "whatwg-url": "^11.0.0" + } + }, + "node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "dev": true, + "license": "MIT" + }, + "node_modules/negotiator": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz", + "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/neo-async": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz", + "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==", + "dev": true, + "license": "MIT" + }, + "node_modules/node-addon-api": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-5.1.0.tgz", + "integrity": "sha512-eh0GgfEkpnoWDq+VY8OyvYhFEzBk6jIYbRKdIlyTiAXIVJ8PyBaKb0rp7oDtoddbdoHWhq8wwr+XZ81F1rpNdA==", + "license": "MIT" + }, + "node_modules/node-domexception": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz", + "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==", + "deprecated": "Use your platform's native DOMException instead", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/jimmywarting" + }, + { + "type": "github", + "url": "https://paypal.me/jimmywarting" + } + ], + "license": "MIT", + "engines": { + "node": ">=10.5.0" + } + }, + "node_modules/node-fetch": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz", + "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==", + "license": "MIT", + "dependencies": { + "whatwg-url": "^5.0.0" + }, + "engines": { + "node": "4.x || >=6.0.0" + }, + "peerDependencies": { + "encoding": "^0.1.0" + }, + "peerDependenciesMeta": { + "encoding": { + "optional": true + } + } + }, + "node_modules/node-fetch-commonjs": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/node-fetch-commonjs/-/node-fetch-commonjs-3.3.2.tgz", + "integrity": "sha512-VBlAiynj3VMLrotgwOS3OyECFxas5y7ltLcK4t41lMUZeaK15Ym4QRkqN0EQKAFL42q9i21EPKjzLUPfltR72A==", + "license": "MIT", + "dependencies": { + "node-domexception": "^1.0.0", + "web-streams-polyfill": "^3.0.3" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/node-fetch" + } + }, + "node_modules/node-fetch/node_modules/tr46": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", + "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==", + "license": "MIT" + }, + "node_modules/node-fetch/node_modules/webidl-conversions": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", + "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==", + "license": "BSD-2-Clause" + }, + "node_modules/node-fetch/node_modules/whatwg-url": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz", + "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==", + "license": "MIT", + "dependencies": { + "tr46": "~0.0.3", + "webidl-conversions": "^3.0.0" + } + }, + "node_modules/node-gyp-build": { + "version": "4.8.4", + "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.8.4.tgz", + "integrity": "sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==", + "license": "MIT", + "bin": { + "node-gyp-build": "bin.js", + "node-gyp-build-optional": "optional.js", + "node-gyp-build-test": "build-test.js" + } + }, + "node_modules/node-releases": { + "version": "2.0.60", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.60.tgz", + "integrity": "sha512-OmO8+GM1JUZqXET720VrJCwkjUCXmCMQm0Z3UDDRbfNLHS4NEAvY60j5jiFv0tkKw2PNNlqOLhahVmwJIOLDIQ==", + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/nodemon": { + "version": "3.1.14", + "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.1.14.tgz", + "integrity": "sha512-jakjZi93UtB3jHMWsXL68FXSAosbLfY0In5gtKq3niLSkrWznrVBzXFNOEMJUfc9+Ke7SHWoAZsiMkNP3vq6Jw==", + "dev": true, + "license": "MIT", + "dependencies": { + "chokidar": "^3.5.2", + "debug": "^4", + "ignore-by-default": "^1.0.1", + "minimatch": "^10.2.1", + "pstree.remy": "^1.1.8", + "semver": "^7.5.3", + "simple-update-notifier": "^2.0.0", + "supports-color": "^5.5.0", + "touch": "^3.1.0", + "undefsafe": "^2.0.5" + }, + "bin": { + "nodemon": "bin/nodemon.js" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/nodemon" + } + }, + "node_modules/nodemon/node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/nodemon/node_modules/brace-expansion": { + "version": "5.0.12", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.12.tgz", + "integrity": "sha512-YovQ3rzhaLMIrDjNDMkNS01tea93qhEhG5xy8f6+R0l+dw3Ki+5sCoIoI942iuLZTHWogWktgwVDhU09iNEimQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/nodemon/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/nodemon/node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/nodemon/node_modules/minimatch": { + "version": "10.2.6", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.6.tgz", + "integrity": "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.8" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/nodemon/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/nodemon/node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/normalize-url": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz", + "integrity": "sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/nth-check": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz", + "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==", + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "^1.0.0" + }, + "funding": { + "url": "https://github.com/fb55/nth-check?sponsor=1" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-inspect": { + "version": "1.13.4", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", + "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/oembed-parser": { + "version": "1.5.2", + "resolved": "https://registry.npmjs.org/oembed-parser/-/oembed-parser-1.5.2.tgz", + "integrity": "sha512-Um9aqB6fu1+DmxyKawuVcP4TpNv7gw9jmd65mIVxkQxR40+BpEz2jrl/0xaahV67omOl9eGv/OxtK0O7zVh5JQ==", + "license": "MIT", + "dependencies": { + "got": "^11.8.2" + }, + "engines": { + "node": ">= 10.14.2" + } + }, + "node_modules/on-finished": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.2.tgz", + "integrity": "sha512-ATWUv387i+nLD49EiDoOft5scf32Vsdz3ktrQJG9bi7jRFmaXTssvyvj1EmeKVVgvesbqUtvQQvaS2TpTukAZQ==", + "license": "MIT", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/one-time": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/one-time/-/one-time-1.0.0.tgz", + "integrity": "sha512-5DXOiRKwuSEcQ/l0kGCF6Q3jcADFv5tSmRaJck/OqkVFcOzutB134KRSfF0xDrL39MNnqxbHBbUUcjZIhTgb2g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fn.name": "1.x.x" + } + }, + "node_modules/open-graph-scraper": { + "version": "4.11.1", + "resolved": "https://registry.npmjs.org/open-graph-scraper/-/open-graph-scraper-4.11.1.tgz", + "integrity": "sha512-cGffZ6MtlEj6e46MqEnRU0qf+OmQDG3YTZOaEI15lhZMGAoUbu0bUsDFaq4QOz3lc9DHC7JprQeyJkTNqs7HjA==", + "license": "MIT", + "dependencies": { + "chardet": "^1.4.0", + "cheerio": "^1.0.0-rc.11", + "got": "^11.8.5", + "iconv-lite": "^0.6.3", + "validator": "^13.7.0" + }, + "engines": { + "node": ">=12.x.x" + } + }, + "node_modules/optionator": { + "version": "0.9.4", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", + "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.5" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/p-cancelable": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-2.1.1.tgz", + "integrity": "sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-try": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz", + "integrity": "sha512-U1etNYuMJoIz3ZXSrrySFjsXQTWOx2/jdi86L+2pRvph/qMKL6sbcCYdH23fqsbm8TH2Gn0OybpT4eSFlCVHww==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/parse-json": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz", + "integrity": "sha512-aOIos8bujGN93/8Ox/jPLh7RwVnPEysynVFE+fQZyg6jKELEHwzgKdLRFHUgXJL6kylijVSBC4BvN9OmsB48Rw==", + "license": "MIT", + "dependencies": { + "error-ex": "^1.3.1", + "json-parse-better-errors": "^1.0.1" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/parse5": { + "version": "7.3.0", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz", + "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==", + "license": "MIT", + "dependencies": { + "entities": "^6.0.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, + "node_modules/parse5-htmlparser2-tree-adapter": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.1.0.tgz", + "integrity": "sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g==", + "license": "MIT", + "dependencies": { + "domhandler": "^5.0.3", + "parse5": "^7.0.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, + "node_modules/parse5-parser-stream": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/parse5-parser-stream/-/parse5-parser-stream-7.1.2.tgz", + "integrity": "sha512-JyeQc9iwFLn5TbvvqACIF/VXG6abODeB3Fwmv/TGdLk2LfbWkaySGY72at4+Ty7EkPZj854u4CrICqNk2qIbow==", + "license": "MIT", + "dependencies": { + "parse5": "^7.0.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, + "node_modules/parse5/node_modules/entities": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz", + "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/parseurl": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", + "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true, + "license": "MIT" + }, + "node_modules/path-to-regexp": { + "version": "0.1.13", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.13.tgz", + "integrity": "sha512-A/AGNMFN3c8bOlvV9RreMdrv7jsmF9XIfDeCd87+I8RNg6s78BhJxMu69NEMHBSJFxKidViTEdruRwEk/WIKqA==", + "license": "MIT" + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz", + "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pify": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", + "integrity": "sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/pkg-conf": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/pkg-conf/-/pkg-conf-2.1.0.tgz", + "integrity": "sha512-C+VUP+8jis7EsQZIhDYmS5qlNtjv2yP4SNtjXK9AP1ZcTRlnSfuumaTnRfYZnYgUUYVIKqL0fRvmUGDV2fmp6g==", + "license": "MIT", + "dependencies": { + "find-up": "^2.0.0", + "load-json-file": "^4.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/pkg-conf/node_modules/find-up": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz", + "integrity": "sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ==", + "license": "MIT", + "dependencies": { + "locate-path": "^2.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/pkg-conf/node_modules/locate-path": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", + "integrity": "sha512-NCI2kiDkyR7VeEKm27Kda/iQHyKJe1Bu0FlTbYp3CqJu+9IFe9bLyAjMxf5ZDDbEg+iMPzB5zYyUTSm8wVTKmA==", + "license": "MIT", + "dependencies": { + "p-locate": "^2.0.0", + "path-exists": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/pkg-conf/node_modules/p-limit": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.3.0.tgz", + "integrity": "sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==", + "license": "MIT", + "dependencies": { + "p-try": "^1.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/pkg-conf/node_modules/p-locate": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz", + "integrity": "sha512-nQja7m7gSKuewoVRen45CtVfODR3crN3goVQ0DDZ9N3yHxgpkuBhZqsaiotSQRrADUrne346peY7kT3TSACykg==", + "license": "MIT", + "dependencies": { + "p-limit": "^1.1.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/pkg-conf/node_modules/path-exists": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", + "integrity": "sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/pkg-dir": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz", + "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "find-up": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/pkg-dir/node_modules/find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dev": true, + "license": "MIT", + "dependencies": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/pkg-dir/node_modules/locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-locate": "^4.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/pkg-dir/node_modules/p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-try": "^2.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/pkg-dir/node_modules/p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-limit": "^2.2.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/pkg-dir/node_modules/p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/possible-typed-array-names": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz", + "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/prismjs": { + "version": "1.30.0", + "resolved": "https://registry.npmjs.org/prismjs/-/prismjs-1.30.0.tgz", + "integrity": "sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/process-nextick-args": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", + "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==", + "license": "MIT" + }, + "node_modules/proxy-addr": { + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.8.tgz", + "integrity": "sha512-5nnx0yGyVUcY6t9RnWcARWtwT9F1D8O9rt08htPvnd49W1IgZtmLkhu9WfMzQj1cFxjHIO6connUNVW5k7AVyQ==", + "license": "MIT", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/pstree.remy": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/pstree.remy/-/pstree.remy-1.1.8.tgz", + "integrity": "sha512-77DZwxQmxKnu3aR542U+X8FypNzbfJ+C5XQDk3uWjWxn6151aIMGthWYRXTqT1E5oJvg+ljaa2OJi+VfvCOQ8w==", + "dev": true, + "license": "MIT" + }, + "node_modules/pump": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.4.tgz", + "integrity": "sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==", + "license": "MIT", + "dependencies": { + "end-of-stream": "^1.1.0", + "once": "^1.3.1" + } + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/qs": { + "version": "6.16.2", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.16.2.tgz", + "integrity": "sha512-VYdnB5S7/0IeXzBacUtwNAaM6d7Y/PgYnNC7bJCI6meqA/OgnsQbZMtVW8Dt2D1PHgbHGtYmhSoEIgvt7xZ2ZA==", + "license": "BSD-3-Clause", + "dependencies": { + "es-define-property": "^1.0.1", + "side-channel": "^1.1.1" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/quick-lru": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz", + "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "license": "MIT", + "dependencies": { + "safe-buffer": "^5.1.0" + } + }, + "node_modules/range-parser": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", + "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/raw-body": { + "version": "2.5.3", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz", + "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==", + "license": "MIT", + "dependencies": { + "bytes": "~3.1.2", + "http-errors": "~2.0.1", + "iconv-lite": "~0.4.24", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/raw-body/node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/readdirp": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "dev": true, + "license": "MIT", + "dependencies": { + "picomatch": "^2.2.1" + }, + "engines": { + "node": ">=8.10.0" + } + }, + "node_modules/rechoir": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.7.1.tgz", + "integrity": "sha512-/njmZ8s1wVeR6pjTZ+0nCnv8SpZNRMT2D1RLOJQESlYFDBvwpTA4KWJpZ+sBJ4+vhjILRcK7JIFdGCdxEAAitg==", + "dev": true, + "license": "MIT", + "dependencies": { + "resolve": "^1.9.0" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve": { + "version": "1.22.13", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.13.tgz", + "integrity": "sha512-Dj/cW9zBV2aRj6XzCxuGIs3ESZKv02jixne3q6jFZYZ3/Tg09gHHviSMDL4kObh9pqSahdRHEnDoaP2gn8YLhA==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "is-core-module": "^2.17.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/resolve-alpn": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz", + "integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==", + "license": "MIT" + }, + "node_modules/resolve-cwd": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz", + "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "resolve-from": "^5.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/resolve-cwd/node_modules/resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/resolve-pkg-maps": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", + "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", + "license": "MIT", + "funding": { + "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" + } + }, + "node_modules/responselike": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/responselike/-/responselike-2.0.1.tgz", + "integrity": "sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw==", + "license": "MIT", + "dependencies": { + "lowercase-keys": "^2.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/reusify": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz", + "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==", + "dev": true, + "license": "MIT", + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rfdc": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz", + "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==", + "license": "MIT" + }, + "node_modules/rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "deprecated": "Rimraf versions prior to v4 are no longer supported", + "dev": true, + "license": "ISC", + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/ripemd160": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.3.tgz", + "integrity": "sha512-5Di9UC0+8h1L6ZD2d7awM7E/T4uA1fJRlx6zk/NvdCCVEoAnFqvHmCuNeIKoCeIixBX/q8uM+6ycDvF8woqosA==", + "license": "MIT", + "dependencies": { + "hash-base": "^3.1.2", + "inherits": "^2.0.4" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/run-series": { + "version": "1.1.9", + "resolved": "https://registry.npmjs.org/run-series/-/run-series-1.1.9.tgz", + "integrity": "sha512-Arc4hUN896vjkqCYrUXquBFtRZdv1PfLbTYP71efP6butxyQ0kWpiNJyAgsxscmQg1cqvHY32/UCBzXedTpU2g==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/safe-stable-stringify": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/safe-stable-stringify/-/safe-stable-stringify-2.5.0.tgz", + "integrity": "sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "license": "MIT" + }, + "node_modules/schema-utils": { + "version": "4.8.1", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.8.1.tgz", + "integrity": "sha512-x39pYlJPyH7Uge5QO64B9XGP9zLDc9WNmiQZc+CE3IzZPvMu3lHOuAMGpYNoPixEL7MSWlGhYTg5UlLSL8G6iw==", + "license": "MIT", + "dependencies": { + "@types/json-schema": "^7.0.15", + "ajv": "^8.20.0", + "ajv-formats": "^3.0.1", + "ajv-keywords": "^5.1.0" + }, + "bin": { + "schema-utils": "bin/schema-utils.js" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.112.0" + }, + "peerDependenciesMeta": { + "webpack": { + "optional": true + } + } + }, + "node_modules/schema-utils/node_modules/ajv": { + "version": "8.20.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.20.0.tgz", + "integrity": "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.3", + "fast-uri": "^3.0.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/schema-utils/node_modules/ajv-keywords": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", + "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.3" + }, + "peerDependencies": { + "ajv": "^8.8.2" + } + }, + "node_modules/schema-utils/node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", + "license": "MIT" + }, + "node_modules/secp256k1": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/secp256k1/-/secp256k1-4.0.5.tgz", + "integrity": "sha512-SQZi5+/uiJIFPYbeRrVuu77Sr3bFOTq0oCQs67CqYwdmg0lhnqi/8djSWhzNO3GKGOqxBYCdx8zJJv0zUwDDvw==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "elliptic": "^6.5.7", + "node-addon-api": "^5.0.0", + "node-gyp-build": "^4.2.0" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/semver": { + "version": "7.8.5", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz", + "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/send": { + "version": "0.19.2", + "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", + "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "~0.5.2", + "http-errors": "~2.0.1", + "mime": "1.6.0", + "ms": "2.1.3", + "on-finished": "~2.4.1", + "range-parser": "~1.2.1", + "statuses": "~2.0.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/send/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/serve-static": { + "version": "1.16.3", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz", + "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==", + "license": "MIT", + "dependencies": { + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "parseurl": "~1.3.3", + "send": "~0.19.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/set-function-length": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz", + "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==", + "license": "MIT", + "dependencies": { + "define-data-property": "^1.1.4", + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.4", + "gopd": "^1.0.1", + "has-property-descriptors": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "license": "ISC" + }, + "node_modules/sha.js": { + "version": "2.4.12", + "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.12.tgz", + "integrity": "sha512-8LzC5+bvI45BjpfXU8V5fdU2mfeKiQe1D1gIMn7XUlF3OTUrpdJpPPH4EMAnF0DsHHdSZqCdSss5qCmJKuiO3w==", + "license": "(MIT AND BSD-3-Clause)", + "dependencies": { + "inherits": "^2.0.4", + "safe-buffer": "^5.2.1", + "to-buffer": "^1.2.0" + }, + "bin": { + "sha.js": "bin.js" + }, + "engines": { + "node": ">= 0.10" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/sha256-file": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/sha256-file/-/sha256-file-1.0.0.tgz", + "integrity": "sha512-nqf+g0veqgQAkDx0U2y2Tn2KWyADuuludZTw9A7J3D+61rKlIIl9V5TS4mfnwKuXZOH9B7fQyjYJ9pKRHIsAyg==", + "license": "MIT" + }, + "node_modules/shallow-clone": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/shallow-clone/-/shallow-clone-3.0.1.tgz", + "integrity": "sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==", + "license": "MIT", + "dependencies": { + "kind-of": "^6.0.2" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/sharp": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.35.5.tgz", + "integrity": "sha512-Ywn4OnzGukp7CDMrp08RQ50YKmuwG47brZgIVPTvBaaAfQlRlygrRqSrxdCiL9M+LlzLBiJ68IR1QqvzHyjC7g==", + "license": "Apache-2.0", + "dependencies": { + "@img/colour": "^1.1.0", + "detect-libc": "^2.1.2", + "semver": "^7.8.5" + }, + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-darwin-arm64": "0.35.5", + "@img/sharp-darwin-x64": "0.35.5", + "@img/sharp-freebsd-wasm32": "0.35.5", + "@img/sharp-libvips-darwin-arm64": "1.3.4", + "@img/sharp-libvips-darwin-x64": "1.3.4", + "@img/sharp-libvips-linux-arm": "1.3.4", + "@img/sharp-libvips-linux-arm64": "1.3.4", + "@img/sharp-libvips-linux-ppc64": "1.3.4", + "@img/sharp-libvips-linux-riscv64": "1.3.4", + "@img/sharp-libvips-linux-s390x": "1.3.4", + "@img/sharp-libvips-linux-x64": "1.3.4", + "@img/sharp-libvips-linuxmusl-arm64": "1.3.4", + "@img/sharp-libvips-linuxmusl-x64": "1.3.4", + "@img/sharp-linux-arm": "0.35.5", + "@img/sharp-linux-arm64": "0.35.5", + "@img/sharp-linux-ppc64": "0.35.5", + "@img/sharp-linux-riscv64": "0.35.5", + "@img/sharp-linux-s390x": "0.35.5", + "@img/sharp-linux-x64": "0.35.5", + "@img/sharp-linuxmusl-arm64": "0.35.5", + "@img/sharp-linuxmusl-x64": "0.35.5", + "@img/sharp-webcontainers-wasm32": "0.35.5", + "@img/sharp-win32-arm64": "0.35.5", + "@img/sharp-win32-ia32": "0.35.5", + "@img/sharp-win32-x64": "0.35.5" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/side-channel": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.1.tgz", + "integrity": "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.4", + "side-channel-list": "^1.0.1", + "side-channel-map": "^1.0.1", + "side-channel-weakmap": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-list": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.1.tgz", + "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3", + "side-channel-map": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/signale": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/signale/-/signale-1.4.0.tgz", + "integrity": "sha512-iuh+gPf28RkltuJC7W5MRi6XAjTDCAPC/prJUpQoG4vIP3MJZ+GTydVnodXA7pwvTKb2cA0m9OFZW/cdWy/I/w==", + "license": "MIT", + "dependencies": { + "chalk": "^2.3.2", + "figures": "^2.0.0", + "pkg-conf": "^2.1.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/signale/node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "license": "MIT", + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/signale/node_modules/chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/signale/node_modules/color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "license": "MIT", + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/signale/node_modules/color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "license": "MIT" + }, + "node_modules/signale/node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "license": "MIT", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/signale/node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/signale/node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "license": "MIT", + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/simple-update-notifier": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz", + "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==", + "dev": true, + "license": "MIT", + "dependencies": { + "semver": "^7.5.3" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/simple-youtube-api": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/simple-youtube-api/-/simple-youtube-api-5.2.1.tgz", + "integrity": "sha512-vmndP9Bkh35tifn2OwY+th2imSsfYtmDqczgdOW5yEARFzvSoR8VSQFsivJnctfV5QHQUL6VrOpNdbmDRLh9Bg==", + "license": "MIT", + "dependencies": { + "iso8601-duration": "^1.2.0", + "node-fetch": "^2.6.0" + } + }, + "node_modules/smart-buffer": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz", + "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==", + "license": "MIT", + "engines": { + "node": ">= 6.0.0", + "npm": ">= 3.0.0" + } + }, + "node_modules/socks": { + "version": "2.8.10", + "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.10.tgz", + "integrity": "sha512-e0VyvkVTwVYViNovRkZ9aodhxVlyoMn7eJhVUPxZ+eK9P/7CBkxvvsBOHqFPEH416726W8tLXXXjKwqgTErrCQ==", + "license": "MIT", + "dependencies": { + "ip-address": "^10.1.1", + "smart-buffer": "^4.2.0" + }, + "engines": { + "node": ">= 10.0.0", + "npm": ">= 3.0.0" + } + }, + "node_modules/source-list-map": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/source-list-map/-/source-list-map-2.0.1.tgz", + "integrity": "sha512-qnQ7gVMxGNxsiL4lEuJwe/To8UnK7fAnmbGEEH8RpLouuKbeEm0lhbQVFIrNSuB+G7tVrAlVsZgETT5nljf+Iw==", + "dev": true, + "license": "MIT" + }, + "node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-support": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", + "license": "MIT", + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "node_modules/sparse-bitfield": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/sparse-bitfield/-/sparse-bitfield-3.0.3.tgz", + "integrity": "sha512-kvzhi7vqKTfkh0PZU+2D2PIllw2ymqJKujUcyPMd9Y75Nv4nPbGJZXNhxsgdQab2BmlDct1YnfQCguEvHr7VsQ==", + "license": "MIT", + "optional": true, + "dependencies": { + "memory-pager": "^1.0.2" + } + }, + "node_modules/stack-trace": { + "version": "0.0.10", + "resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-0.0.10.tgz", + "integrity": "sha512-KGzahc7puUKkzyMt+IqAep+TVNbKP+k2Lmwhub39m1AsTSkaDutx56aDCo+HLDzf/D26BIHTJWNiTG1KAJiQCg==", + "dev": true, + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/statuses": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", + "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/stream-browserify": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/stream-browserify/-/stream-browserify-3.0.0.tgz", + "integrity": "sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA==", + "license": "MIT", + "dependencies": { + "inherits": "~2.0.4", + "readable-stream": "^3.5.0" + } + }, + "node_modules/streamroller": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/streamroller/-/streamroller-3.1.5.tgz", + "integrity": "sha512-KFxaM7XT+irxvdqSP1LGLgNWbYN7ay5owZ3r/8t77p+EtSUAfUgtl7be3xtqtOmGUl9K9YPO2ca8133RlTjvKw==", + "license": "MIT", + "dependencies": { + "date-format": "^4.0.14", + "debug": "^4.3.4", + "fs-extra": "^8.1.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/streamroller/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/streamroller/node_modules/fs-extra": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz", + "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==", + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^4.0.0", + "universalify": "^0.1.0" + }, + "engines": { + "node": ">=6 <7 || >=8" + } + }, + "node_modules/streamroller/node_modules/jsonfile": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz", + "integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==", + "license": "MIT", + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/streamroller/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/streamroller/node_modules/universalify": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz", + "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==", + "license": "MIT", + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/string_decoder": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "license": "MIT", + "dependencies": { + "safe-buffer": "~5.2.0" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/style-loader": { + "version": "3.3.4", + "resolved": "https://registry.npmjs.org/style-loader/-/style-loader-3.3.4.tgz", + "integrity": "sha512-0WqXzrsMTyb8yjZJHDqwmnwRJvhALK9LfRtRc6B4UTWe8AijYLZYZ9thuJTZc2VfQWINADW/j+LiJnfy2RoC1w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.0.0" + } + }, + "node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/tapable": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.3.tgz", + "integrity": "sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==", + "license": "MIT", + "engines": { + "node": ">=6" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/terser": { + "version": "5.51.2", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.51.2.tgz", + "integrity": "sha512-bWnjSNscmuI+GJze6ZupnHP8G/cTcsJF+bXCeQknk2SHQsgbNJnLrqiH9jZ2W4STPVXH2mDKKRX3iwPhc9Cn/Q==", + "license": "BSD-2-Clause", + "dependencies": { + "@jridgewell/source-map": "^0.3.3", + "acorn": "^8.15.0", + "commander": "^2.20.0", + "source-map-support": "~0.5.20" + }, + "bin": { + "terser": "bin/terser" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/text-hex": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/text-hex/-/text-hex-1.0.0.tgz", + "integrity": "sha512-uuVGNWzgJ4yhRaNSiubPY7OjISw4sw4E5Uv0wbjp+OzcbmVU/rsT8ujgcXJhn9ypzsgr5vlzpPqP+MBBKcGvbg==", + "dev": true, + "license": "MIT" + }, + "node_modules/text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==", + "dev": true, + "license": "MIT" + }, + "node_modules/to-buffer": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/to-buffer/-/to-buffer-1.2.2.tgz", + "integrity": "sha512-db0E3UJjcFhpDhAF4tLo03oli3pwl3dbnzXOUIlRKrp+ldk/VUxzpWYZENsw2SZiuBjHAk7DfB0VU7NKdpb6sw==", + "license": "MIT", + "dependencies": { + "isarray": "^2.0.5", + "safe-buffer": "^5.2.1", + "typed-array-buffer": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "license": "MIT", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/touch": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/touch/-/touch-3.1.1.tgz", + "integrity": "sha512-r0eojU4bI8MnHr8c5bNo7lJDdI2qXlWWJk6a9EAFG7vbhTjElYhBVS3/miuE0uOuoLdb8Mc/rVfsmm6eo5o9GA==", + "dev": true, + "license": "ISC", + "bin": { + "nodetouch": "bin/nodetouch.js" + } + }, + "node_modules/tr46": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-3.0.0.tgz", + "integrity": "sha512-l7FvfAHlcmulp8kr+flpQZmVwtu7nfRV7NZujtN0OqES8EL4O4e0qqzL0DC5gAvx/ZC/9lk6rhcUwYvkBnBnYA==", + "license": "MIT", + "dependencies": { + "punycode": "^2.1.1" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/triple-beam": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/triple-beam/-/triple-beam-1.4.1.tgz", + "integrity": "sha512-aZbgViZrg1QNcG+LULa7nhZpJTZSLm/mXnHXnbAbjmN5aSa0y7V+wvv6+4WaBtpISJzThKy+PIPxc1Nq1EJ9mg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/tslib": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "license": "0BSD" + }, + "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "dev": true, + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/type-is": { + "version": "1.6.18", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz", + "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==", + "license": "MIT", + "dependencies": { + "media-typer": "0.3.0", + "mime-types": "~2.1.24" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/typed-array-buffer": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz", + "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "es-errors": "^1.3.0", + "is-typed-array": "^1.1.14" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/typeforce": { + "version": "1.18.0", + "resolved": "https://registry.npmjs.org/typeforce/-/typeforce-1.18.0.tgz", + "integrity": "sha512-7uc1O8h1M1g0rArakJdf0uLRSSgFcYexrVoKo+bzJd32gd4gDy2L/Z+8/FjPnU9ydY3pEnVPtr9FyscYY60K1g==", + "license": "MIT" + }, + "node_modules/uc.micro": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/uc.micro/-/uc.micro-1.0.6.tgz", + "integrity": "sha512-8Y75pvTYkLJW2hWQHXxoqRgV7qb9B+9vFEtidML+7koHUFapnVJAZ6cKs+Qjz5Aw3aZWHMC6u0wJE3At+nSGwA==", + "dev": true, + "license": "MIT" + }, + "node_modules/uglify-js": { + "version": "3.19.3", + "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.19.3.tgz", + "integrity": "sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ==", + "dev": true, + "license": "BSD-2-Clause", + "optional": true, + "bin": { + "uglifyjs": "bin/uglifyjs" + }, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/undefsafe": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-2.0.5.tgz", + "integrity": "sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==", + "dev": true, + "license": "MIT" + }, + "node_modules/undici": { + "version": "7.30.1", + "resolved": "https://registry.npmjs.org/undici/-/undici-7.30.1.tgz", + "integrity": "sha512-03KrMbjIFDWQR5RNPrSw3bd1r12JpyFQl9/yxjUbJtqkjmllqC5lFjZh6ujeuJCKr8EOQvRW872Oy/az+nLYxg==", + "license": "MIT", + "engines": { + "node": ">=20.18.1" + } + }, + "node_modules/undici-types": { + "version": "8.9.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-8.9.0.tgz", + "integrity": "sha512-KTDyRTYX8sWmKXAikPHHSyc63CRPETMctyjKFupcC6OBLXT3xsN0e9aF7m+mIXutFWpUXuedtowG7iLOzp0kQg==", + "license": "MIT" + }, + "node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.4.tgz", + "integrity": "sha512-t8wonIOdQyOjtPd2VktlBu6QjTVTks6v8bSi7kd0r2Vll8TK1JYDZtRRdbmCHOAMphkZgrzK+L+vXK4pyZ8t4A==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "license": "MIT" + }, + "node_modules/utils-merge": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz", + "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==", + "license": "MIT", + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/validator": { + "version": "13.15.35", + "resolved": "https://registry.npmjs.org/validator/-/validator-13.15.35.tgz", + "integrity": "sha512-TQ5pAGhd5whStmqWvYF4OjQROlmv9SMFVt37qoCBdqRffuuklWYQlCNnEs2ZaIBD1kZRNnikiZOS1eqgkar0iw==", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/watchpack": { + "version": "2.6.3", + "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.6.3.tgz", + "integrity": "sha512-s3NZy0QpTY9qGqzc0wtz4qI28z3+5qKbbAec4MV4G9N3CfgZ9wgvQRr0cl2jh/tqkWG1NWHkmVMHZpCamev5Wg==", + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.1.2" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/web-streams-polyfill": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz", + "integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==", + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/webidl-conversions": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-7.0.0.tgz", + "integrity": "sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=12" + } + }, + "node_modules/webpack": { + "version": "5.112.2", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.112.2.tgz", + "integrity": "sha512-B2tp1LI9D8GVpPDqprdt12ukTkXXahj9MzqSWJq4faSPgOUM7CdZaGAB6HrL/8E6UwbBpdj4vzWDbKoFnVoU6g==", + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.8", + "@types/json-schema": "^7.0.15", + "@webassemblyjs/ast": "^1.14.1", + "@webassemblyjs/wasm-edit": "^1.14.1", + "@webassemblyjs/wasm-parser": "^1.14.1", + "browserslist": "^4.28.1", + "chrome-trace-event": "^1.0.2", + "enhanced-resolve": "^5.26.0", + "es-module-lexer": "^2.1.0", + "events": "^3.2.0", + "graceful-fs": "^4.2.11", + "mime-db": "^1.54.0", + "minimizer-webpack-plugin": "^5.13.0", + "schema-utils": "^4.8.1", + "tapable": "^2.3.0", + "watchpack": "^2.6.3", + "webpack-sources": "^3.6.0" + }, + "bin": { + "webpack": "bin/webpack.js" + }, + "engines": { + "node": ">=10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependenciesMeta": { + "webpack-cli": { + "optional": true + } + } + }, + "node_modules/webpack-cli": { + "version": "4.10.0", + "resolved": "https://registry.npmjs.org/webpack-cli/-/webpack-cli-4.10.0.tgz", + "integrity": "sha512-NLhDfH/h4O6UOy+0LSso42xvYypClINuMNBVVzX4vX98TmTaTUxwRbXdhucbFMd2qLaCTcLq/PdYrvi8onw90w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@discoveryjs/json-ext": "^0.5.0", + "@webpack-cli/configtest": "^1.2.0", + "@webpack-cli/info": "^1.5.0", + "@webpack-cli/serve": "^1.7.0", + "colorette": "^2.0.14", + "commander": "^7.0.0", + "cross-spawn": "^7.0.3", + "fastest-levenshtein": "^1.0.12", + "import-local": "^3.0.2", + "interpret": "^2.2.0", + "rechoir": "^0.7.0", + "webpack-merge": "^5.7.3" + }, + "bin": { + "webpack-cli": "bin/cli.js" + }, + "engines": { + "node": ">=10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "4.x.x || 5.x.x" + }, + "peerDependenciesMeta": { + "@webpack-cli/generators": { + "optional": true + }, + "@webpack-cli/migrate": { + "optional": true + }, + "webpack-bundle-analyzer": { + "optional": true + }, + "webpack-dev-server": { + "optional": true + } + } + }, + "node_modules/webpack-cli/node_modules/commander": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz", + "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10" + } + }, + "node_modules/webpack-merge": { + "version": "5.10.0", + "resolved": "https://registry.npmjs.org/webpack-merge/-/webpack-merge-5.10.0.tgz", + "integrity": "sha512-+4zXKdx7UnO+1jaN4l2lHVD+mFvnlZQP/6ljaJVb4SZiwIKeUnrT5l0gkT8z+n4hKpC+jpOv6O9R+gLtag7pSA==", + "dev": true, + "license": "MIT", + "dependencies": { + "clone-deep": "^4.0.1", + "flat": "^5.0.2", + "wildcard": "^2.0.0" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/webpack-sources": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.6.0.tgz", + "integrity": "sha512-EIMmPVvNI0CYXyRPp34F2Qk7W37/BZVZIofS6LAUnrNjCVahS+hO4mxwFJDjQjODTGZDtVzLYoN2+1dYkhk9qA==", + "license": "MIT", + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/webpack/node_modules/mime-db": { + "version": "1.54.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz", + "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/whatwg-encoding": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-3.1.1.tgz", + "integrity": "sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==", + "deprecated": "Use @exodus/bytes instead for a more spec-conformant and faster implementation", + "license": "MIT", + "dependencies": { + "iconv-lite": "0.6.3" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/whatwg-mimetype": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-4.0.0.tgz", + "integrity": "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==", + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/whatwg-url": { + "version": "11.0.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-11.0.0.tgz", + "integrity": "sha512-RKT8HExMpoYx4igMiVMY83lN6UeITKJlBQ+vR/8ZJ8OCdSiN3RwCq+9gH0+Xzj0+5IrM6i4j/6LuvzbZIQgEcQ==", + "license": "MIT", + "dependencies": { + "tr46": "^3.0.0", + "webidl-conversions": "^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/which-typed-array": { + "version": "1.1.24", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.24.tgz", + "integrity": "sha512-wk4Mf4pR5mRP7eYuuTBCIQ9d0ud2Fv2jRLQpfgnRjbOxAFHmjKFValgTpitVKzJJS8ajnYQV2Du1SZ8j6b/EUQ==", + "license": "MIT", + "dependencies": { + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.9", + "call-bound": "^1.0.4", + "for-each": "^0.3.5", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/wif": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/wif/-/wif-2.0.6.tgz", + "integrity": "sha512-HIanZn1zmduSF+BQhkE+YXIbEiH0xPr1012QbFEGB0xsKqJii0/SqJjyn8dFv6y36kOznMgMB+LGcbZTJ1xACQ==", + "license": "MIT", + "dependencies": { + "bs58check": "<3.0.0" + } + }, + "node_modules/wildcard": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/wildcard/-/wildcard-2.0.1.tgz", + "integrity": "sha512-CC1bOL87PIWSBhDcTrdeLo6eGT7mCFtrg0uIJtqJUFyK+eJnzl8A1niH56uu7KMa5XFrtiV+AQuHO3n7DsHnLQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/winston": { + "version": "3.19.0", + "resolved": "https://registry.npmjs.org/winston/-/winston-3.19.0.tgz", + "integrity": "sha512-LZNJgPzfKR+/J3cHkxcpHKpKKvGfDZVPS4hfJCc4cCG0CgYzvlD6yE/S3CIL/Yt91ak327YCpiF/0MyeZHEHKA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@colors/colors": "^1.6.0", + "@dabh/diagnostics": "^2.0.8", + "async": "^3.2.3", + "is-stream": "^2.0.0", + "logform": "^2.7.0", + "one-time": "^1.0.0", + "readable-stream": "^3.4.0", + "safe-stable-stringify": "^2.3.1", + "stack-trace": "0.0.x", + "triple-beam": "^1.3.0", + "winston-transport": "^4.9.0" + }, + "engines": { + "node": ">= 12.0.0" + } + }, + "node_modules/winston-transport": { + "version": "4.9.0", + "resolved": "https://registry.npmjs.org/winston-transport/-/winston-transport-4.9.0.tgz", + "integrity": "sha512-8drMJ4rkgaPo1Me4zD/3WLfI/zPdA9o2IipKODunnGDcuqbHwjsbB79ylv04LCGGzU0xQ6vTznOMpQGaLhhm6A==", + "dev": true, + "license": "MIT", + "dependencies": { + "logform": "^2.7.0", + "readable-stream": "^3.6.2", + "triple-beam": "^1.3.0" + }, + "engines": { + "node": ">= 12.0.0" + } + }, + "node_modules/word-wrap": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/wordwrap": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", + "integrity": "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "license": "ISC" + }, + "node_modules/ws": { + "version": "7.5.13", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.13.tgz", + "integrity": "sha512-rsKI6xDBFVf4r/x8XyChGK04QR/XHroxs/jUcoWvtEZM8TPU/X/uIY9B1CsSzYws9ZJb/6bbBu7dPhFW00CAoA==", + "license": "MIT", + "engines": { + "node": ">=8.3.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": "^5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + } + } +} diff --git a/package.json b/package.json index 8545344..7b074bd 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "avalon", - "version": "1.6.6", + "version": "2.0.3", "description": "", "scripts": { "start": "node src/main.js", @@ -9,34 +9,34 @@ "apidoc": "apidoc -i src/http -o apidoc" }, "dependencies": { - "base-x": "^3.0.8", - "body-parser": "^1.15.2", - "bson": "^4.6.0", + "base-x": "^3.0.11", + "body-parser": "^1.20.5", + "bson": "^4.7.2", "clone-deep": "^4.0.1", - "commander": "^2.20.0", - "cors": "^2.8.5", - "crypto-js": "^4.2.0", + "commander": "^2.20.3", + "cors": "^2.8.6", "decay": "^1.0.12", - "esbuild-loader": "^4.3.0", - "express": "^4.16.4", + "esbuild-loader": "^4.5.0", + "express": "^4.22.2", + "express-rate-limit": "^8.5.2", "growint": "^1.0.1", - "javalon2": "^1.1.7", - "log4js": "^6.6.0", - "mongodb": "^4.2.2", - "node-fetch-commonjs": "^3.2.4", - "oembed-parser": "^1.2.2", - "open-graph-scraper": "^4.11.0", - "run-parallel": "^1.1.10", + "javalon2": "^1.1.10", + "log4js": "^6.9.1", + "mongodb": "^4.17.2", + "node-fetch-commonjs": "^3.3.2", + "oembed-parser": "^1.5.2", + "open-graph-scraper": "^4.11.1", + "run-parallel": "^1.2.0", "run-series": "^1.1.9", - "secp256k1": "^4.0.2", + "secp256k1": "^4.0.4", "sha256-file": "^1.0.0", - "sharp": "^0.32.6", + "sharp": "^0.35.5", "signale": "^1.4.0", "simple-youtube-api": "^5.2.1", - "ws": "^7.5.3" + "ws": "^7.5.11" }, "engines": { - "node": ">=4.3.2" + "node": ">=24.0.0" }, "signale": { "coloredInterpolation": false, @@ -61,7 +61,7 @@ }, "devDependencies": { "apidoc": "^1.2.0", - "chance": "^1.0.18", - "eslint": "^8.5.0" + "chance": "^1.1.13", + "eslint": "^8.57.1" } } diff --git a/scripts/auto_resolve_halt.sh b/scripts/auto_resolve_halt.sh new file mode 100755 index 0000000..ef4e014 --- /dev/null +++ b/scripts/auto_resolve_halt.sh @@ -0,0 +1,796 @@ +#!/bin/bash +# auto_resolve_halt.sh - Automatic blockchain halt resolution (fallback) +# Detects chain stalls and attempts recovery including block truncation. +# This script is the LAST-RESORT fallback for the in-process force finalization +# mechanism (src/consensus.js). Force finalization automatically resolves block +# conflicts at the consensus level without data loss. This script handles +# scenarios force finalization cannot: no leader producing blocks, node crashes, +# MongoDB issues, or force finalization itself failing. +# Usage: ./scripts/auto_resolve_halt.sh [options] + +set -euo pipefail + +PROJECT_DIR="$(cd "$(dirname "$0")/.." && pwd)" +cd "$PROJECT_DIR" + +# === Configuration (may be overridden via env) === +HTTP_PORT="${HTTP_PORT:-3001}" +HTTP_HOST="${HTTP_HOST:-0.0.0.0}" +HALT_TIMEOUT_SEC="${HALT_TIMEOUT_SEC:-30}" +MAX_REMOVE_BLOCKS="${MAX_REMOVE_BLOCKS:-10}" +BLOCKS_DIR="${BLOCKS_DIR:-}" +DB_NAME="${DB_NAME:-avalon}" +DB_URL="${DB_URL:-mongodb://localhost:27017}" +NODE_OWNER="${NODE_OWNER:-}" +DRY_RUN="${DRY_RUN:-0}" + +# Truncation safety: prevent repeated truncation from wiping the chain +HALT_STATE_DIR="${HALT_STATE_DIR:-${PROJECT_DIR}/.avalon_halt}" +MAX_TOTAL_REMOVE="${MAX_TOTAL_REMOVE:-$((MAX_REMOVE_BLOCKS * 3))}" +STATE_FILE="${HALT_STATE_DIR}/state.json" + +mkdir -p "$HALT_STATE_DIR" + +load_state() { + if [ -f "$STATE_FILE" ]; then + cat "$STATE_FILE" + else + echo '{"last_truncated_height":0,"total_removed":0,"last_truncation_ts":0}' + fi +} + +save_state() { + echo "$1" > "${STATE_FILE}.tmp" && mv "${STATE_FILE}.tmp" "$STATE_FILE" +} + +check_truncation_safety() { + local current_height="$1" + local to_remove="$2" + local state + state=$(load_state) + + local last_height + last_height=$(echo "$state" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.parse(d).last_truncated_height||0))") + local total_removed + total_removed=$(echo "$state" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.parse(d).total_removed||0))") + + # Prevent removing blocks that were already truncated before (no forward progress) + # Skip this check when current_height is 0 (node was offline, height unknown) + if [ "$current_height" -gt 0 ] && [ "$current_height" -le "$last_height" ]; then + err "Chain height ($current_height) has not progressed since last truncation ($last_height). Refusing to truncate again." + err "This prevents a loop that could wipe the entire chain." + err "Manual intervention required." + return 1 + fi + + # Enforce cumulative cap + local new_total=$(( total_removed + to_remove )) + if [ "$new_total" -gt "$MAX_TOTAL_REMOVE" ]; then + err "Cumulative blocks removed ($new_total) would exceed MAX_TOTAL_REMOVE ($MAX_TOTAL_REMOVE). Refusing to truncate." + err "Previously removed: $total_removed, attempting to remove: $to_remove more." + err "Increase MAX_TOTAL_REMOVE or reset ${STATE_FILE} to force." + return 1 + fi + + info "Truncation safety check passed (last_truncated=$last_height, total_removed=$total_removed, removing=$to_remove)" + return 0 +} + +update_state_after_truncation() { + local new_height="$1" + local removed="$2" + local state + state=$(load_state) + + local total_removed + total_removed=$(echo "$state" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.parse(d).total_removed||0))") + + local new_state + new_state=$(cat <&2; } +err() { log "ERROR: $*"; } +warn() { log "WARN: $*"; } +info() { log "INFO: $*"; } + +api_get() { + curl -sf --max-time 5 "http://${HTTP_HOST}:${HTTP_PORT}${1}" 2>/dev/null || true +} + +# === Detection === + +get_latest_block() { + local count + count=$(api_get "/count" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.parse(d).count))" 2>/dev/null || echo "") + if [ -z "$count" ] || [ "$count" = "null" ]; then + return 1 + fi + local block_json + block_json=$(api_get "/block/${count}") + if [ -z "$block_json" ] || [ "$block_json" = "{}" ]; then + return 1 + fi + echo "$block_json" +} + +get_config() { + local cfg + cfg=$(api_get "/config") + if [ -z "$cfg" ] || [ "$cfg" = "{}" ]; then + return 1 + fi + echo "$cfg" +} + +is_node_running() { + if command -v pgrep &>/dev/null; then + pgrep -f "node.*src/main" &>/dev/null + elif command -v pidof &>/dev/null; then + pidof "node" &>/dev/null + else + # fallback: try the HTTP endpoint + api_get "/count" &>/dev/null + fi +} + +stop_node() { + local pid + pid=$(pgrep -f "node.*src/main" 2>/dev/null || true) + if [ -n "$pid" ]; then + info "Stopping node (PID $pid)..." + if [ "$DRY_RUN" = "1" ]; then + info "[DRY-RUN] Would kill PID $pid" + return 0 + fi + kill "$pid" 2>/dev/null || true + local waited=0 + while kill -0 "$pid" 2>/dev/null; do + sleep 1 + waited=$((waited + 1)) + if [ "$waited" -ge 15 ]; then + warn "Node did not stop gracefully, force killing..." + kill -9 "$pid" 2>/dev/null || true + sleep 1 + break + fi + done + info "Node stopped" + else + info "Node is not running" + fi +} + +start_node_with_rebuild() { + if [ "$DRY_RUN" = "1" ]; then + info "[DRY-RUN] Would start node with REBUILD_STATE=1:" + info " REBUILD_STATE=1 node --stack-size=65500 src/main" + return 0 + fi + info "Starting node with REBUILD_STATE=1..." + export REBUILD_STATE=1 + if [ -f scripts/start.sh ]; then + exec bash scripts/start.sh + else + exec node --stack-size=65500 src/main + fi +} + +# === Block Truncation (BSON) === + +truncate_blocks_bson() { + local remove_count="$1" + local bson_path="${BLOCKS_DIR}/blocks.bson" + local idx_path="${BLOCKS_DIR}/blocks.index" + + if [ ! -f "$bson_path" ]; then + err "blocks.bson not found at $bson_path" + return 1 + fi + if [ ! -f "$idx_path" ]; then + err "blocks.index not found at $idx_path" + return 1 + fi + + info "Truncating BSON storage: removing $remove_count blocks" + + local output new_height + output=$(IDX_PATH="$idx_path" BSON_PATH="$bson_path" REMOVE_COUNT="$remove_count" DRY_RUN="$DRY_RUN" node -e ' + const fs = require("fs"); + const idxPath = process.env.IDX_PATH; + const bsonPath = process.env.BSON_PATH; + const remove = parseInt(process.env.REMOVE_COUNT, 10); + const isDryRun = process.env.DRY_RUN === "1"; + + if (!fs.existsSync(idxPath)) { console.error("Index not found:", idxPath); process.exit(1); } + if (!fs.existsSync(bsonPath)) { console.error("BSON not found:", bsonPath); process.exit(1); } + + const idxSize = fs.statSync(idxPath).size; + const bsonSize = fs.statSync(bsonPath).size; + const totalBlocks = idxSize / 8; + const newHeight = totalBlocks - remove - 1; + + if (newHeight < 0) { + console.error("Cannot remove", remove, "blocks from only", (totalBlocks-1), "total"); + process.exit(1); + } + + const buf = Buffer.alloc(8); + const idxFd = fs.openSync(idxPath, "r"); + fs.readSync(idxFd, buf, 0, 8, (newHeight + 1) * 8); + fs.closeSync(idxFd); + + const high = buf.readUInt32LE(0); + const low = buf.readUInt32LE(4); + // blocks.js encodes pos as high = pos >> 8, low = pos & 0xFF + // (appendIndex/read: `(high << 8) + low`) — decode must mirror it + const truncPos = (BigInt(high) << 8n) + BigInt(low); + const idxTruncSize = (newHeight + 1) * 8; + + if (Number(truncPos) > bsonSize || truncPos < 0n) { + console.error("Invalid truncation position: " + truncPos + " (BSON file size: " + bsonSize + " bytes)"); + process.exit(1); + } + + console.log("KEEPING blocks 0 - " + newHeight + " (" + (newHeight+1) + " total)"); + console.log(" index: " + idxSize + " -> " + idxTruncSize + " bytes"); + console.log(" bson: " + bsonSize + " -> " + truncPos + " bytes"); + + if (!isDryRun) { + fs.truncateSync(idxPath, idxTruncSize); + fs.truncateSync(bsonPath, Number(truncPos)); + console.log("Truncation done"); + } else { + console.log("[DRY-RUN] No files modified"); + } + + console.log(newHeight); + ') || return 1 + + new_height=$(echo "$output" | tail -1) + info "BSON truncation complete: kept blocks 0 - $new_height" + echo "$new_height" +} + +# === MongoDB Helpers === + +is_positive_integer() { + case "$1" in + ''|*[!0-9]*) return 1 ;; + *) return 0 ;; + esac +} + +find_mongo_cmd() { + if command -v mongosh &>/dev/null; then + echo "mongosh" + elif command -v mongo &>/dev/null; then + echo "mongo" + else + return 1 + fi +} + +run_mongo() { + local mongo_cmd + mongo_cmd=$(find_mongo_cmd) || return 1 + "$mongo_cmd" "$DB_URL/$DB_NAME" --quiet --eval "$1" +} + +# === Block Truncation (MongoDB) === + +truncate_blocks_mongo() { + local remove_count="$1" + + info "Truncating MongoDB storage: removing $remove_count blocks" + + local mongo_cmd + mongo_cmd=$(find_mongo_cmd) || { + err "Neither mongosh nor mongo CLI found" + return 1 + } + + local output new_height + + output=$(REMOVE_COUNT="$remove_count" DRY_RUN="$DRY_RUN" run_mongo " + const remove = parseInt(process.env.REMOVE_COUNT, 10); + const isDryRun = process.env.DRY_RUN === '1'; + const lastBlock = db.blocks.find().sort({_id:-1}).limit(1).next(); + if (!lastBlock) { + print('ERROR: No blocks found'); + quit(1); + } + const oldHeight = lastBlock._id; + const newHeight = oldHeight - remove; + if (newHeight < 0) { + print('ERROR: Cannot remove ' + remove + ' blocks, only have ' + (oldHeight+1)); + quit(1); + } + if (isDryRun) { + print('[DRY-RUN] Would delete ' + remove + ' blocks, keeping 0 - ' + newHeight); + } else { + const result = db.blocks.deleteMany({_id: {\$gt: newHeight}}); + print('Deleted ' + result.deletedCount + ' blocks'); + } + print('KEEPING blocks 0 - ' + newHeight + ' (' + (newHeight+1) + ' total)'); + print(newHeight); + ") || { + err "MongoDB truncation failed" + return 1 + } + + new_height=$(echo "$output" | tail -1) + echo "$output" | head -n -1 | while IFS= read -r line; do info "$line"; done + info "MongoDB truncation complete: kept blocks 0 - $new_height" + echo "$new_height" +} + +# === MongoDB State Cleanup === + +cleanup_mongodb_state() { + local new_height="$1" + + local mongo_cmd + mongo_cmd=$(find_mongo_cmd) || { + err "Cannot find mongosh or mongo CLI for state cleanup" + return 1 + } + + if [ -n "$BLOCKS_DIR" ]; then + # BSON mode: blocks are safe in files, drop entire MongoDB + info "Dropping MongoDB database (BSON mode, blocks are on disk)..." + if [ "$DRY_RUN" = "1" ]; then + info "[DRY-RUN] Would drop database $DB_NAME" + return 0 + fi + run_mongo " + const result = db.dropDatabase(); + print('Database dropped: ' + JSON.stringify(result)); + " || { + err "Failed to drop database" + return 1 + } + info "MongoDB database dropped successfully" + else + # MongoDB mode: preserve kept blocks, drop everything else + local tmp_coll="blocks_tmp_truncation" + info "Preserving kept blocks, resetting MongoDB state..." + if [ "$DRY_RUN" = "1" ]; then + info "[DRY-RUN] Would move kept blocks (≤ #$new_height) to temp, drop DB, restore" + return 0 + fi + if ! is_positive_integer "$new_height"; then + err "Invalid block height: $new_height" + return 1 + fi + + NEW_HEIGHT="$new_height" TMP_COLL="$tmp_coll" run_mongo " + const newHeight = parseInt(process.env.NEW_HEIGHT, 10); + const tmpColl = process.env.TMP_COLL; + // Copy kept blocks to temp collection + const docs = db.blocks.aggregate([ + {\$match: {_id: {\$lte: newHeight}}}, + {\$out: tmpColl} + ]); + const kept = db.getCollection(tmpColl).countDocuments(); + if (kept === 0) { + print('ERROR: No blocks to preserve'); + quit(1); + } + print('Preserved ' + kept + ' blocks (0 - #' + newHeight + ')'); + + // Drop everything except temp collection + db.getCollectionNames().forEach(function(c) { + if (c !== tmpColl) { + db.getCollection(c).drop(); + } + }); + print('Collections dropped (except temp)'); + + // Restore blocks from temp + db.getCollection(tmpColl).aggregate([ + {\$match: {}}, + {\$out: 'blocks'} + ]); + db.getCollection(tmpColl).drop(); + print('Blocks restored, temp collection removed'); + " || { + err "Failed to reset MongoDB state" + return 1 + } + info "MongoDB state reset, blocks preserved" + fi +} + +# === Halt Detection Logic === + +check_halt() { + info "Checking blockchain status..." + + if ! is_node_running; then + err "Node is not running" + return 2 + fi + + local block_json + block_json=$(get_latest_block) || { + err "Cannot get latest block (HTTP API not responding)" + return 2 + } + + local height timestamp miner + height=$(echo "$block_json" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const b=JSON.parse(d);console.log(b._id)})") + timestamp=$(echo "$block_json" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const b=JSON.parse(d);console.log(b.timestamp)})") + miner=$(echo "$block_json" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const b=JSON.parse(d);console.log(b.miner)})") + + local now + now=$(date +%s%3N) + local elapsed=$(( (now - timestamp) / 1000 )) + + info "Latest block: #$height by $miner, ${elapsed}s ago" + + if [ "$elapsed" -gt "$HALT_TIMEOUT_SEC" ]; then + warn "Chain appears halted! Last block was ${elapsed}s ago (timeout: ${HALT_TIMEOUT_SEC}s)" + return 1 + fi + + info "Chain is healthy (last block ${elapsed}s ago)" + return 0 +} + +# === Recovery Steps === + +try_recover() { + info "Step 1: Trying /recover endpoint..." + local resp + resp=$(api_get "/recover") + info "Recovery triggered: $(echo "$resp" | head -c 200)" + sleep 10 + + if check_halt; then + info "Chain recovered after /recover" + return 0 + fi + warn "Chain still halted after /recover" + return 1 +} + +try_mine_block() { + info "Step 2: Trying /mineBlock endpoint..." + if [ -n "$NODE_OWNER" ]; then + info "NODE_OWNER is '$NODE_OWNER' - attempting forced block production" + fi + local resp + resp=$(api_get "/mineBlock" 2>/dev/null || echo "failed") + info "mineBlock response: $(echo "$resp" | head -c 200)" + sleep 10 + + if check_halt; then + info "Chain recovered after /mineBlock" + return 0 + fi + warn "Chain still halted after /mineBlock" + return 1 +} + +wait_force_finalize() { + local cfg="$1" + local force_finalize + force_finalize=$(echo "$cfg" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const c=JSON.parse(d);console.log(c.forceFinalize===true?'true':'false')})" 2>/dev/null || echo "false") + + if [ "$force_finalize" != "true" ]; then + info "skip wait: forceFinalize not enabled in config" + return 1 + fi + + local leaders block_time consensus_rounds + leaders=$(echo "$cfg" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.parse(d).leaders||5))" 2>/dev/null || echo "5") + block_time=$(echo "$cfg" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.parse(d).blockTime||3000))" 2>/dev/null || echo "3000") + consensus_rounds=$(echo "$cfg" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.parse(d).consensusRounds||2))" 2>/dev/null || echo "2") + + local wait_ms=$(( block_time * (leaders + consensus_rounds + 2) + 10000 )) + local wait_sec=$(( wait_ms / 1000 )) + + info "forceFinalize is enabled — waiting up to ${wait_sec}s for automatic resolution (timeout=${block_time}ms * (leaders=${leaders} + rounds=${consensus_rounds} + 2) + 10s margin)" + + local block_json before_height now deadline + block_json=$(get_latest_block) || true + before_height=$(echo "$block_json" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const b=JSON.parse(d);console.log(b._id)})" 2>/dev/null || echo "0") + now=$(date +%s) + deadline=$(( now + wait_sec )) + + while [ "$(date +%s)" -lt "$deadline" ]; do + sleep 5 + if check_halt 2>/dev/null; then + info "Chain recovered during auto-wait (force finalization or normal consensus resumed)" + return 0 + fi + local new_block_json + new_block_json=$(get_latest_block) || continue + local new_height + new_height=$(echo "$new_block_json" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const b=JSON.parse(d);console.log(b._id)})" 2>/dev/null || echo "0") + if [ "$new_height" -gt "$before_height" ]; then + info "Chain progressed to height $new_height (was $before_height) — halt resolved" + return 0 + fi + done + + warn "Force finalization did not resolve halt within ${wait_sec}s — proceeding to truncation" + return 1 +} + +# === Main Flow === + +show_help() { + cat <<'EOF' +auto_resolve_halt.sh - Blockchain halt resolution (LAST-RESORT fallback) + +Detects chain stalls and attempts recovery. This is the external fallback +for the in-process force finalization mechanism (src/consensus.js) which +automatically resolves block collisions at the consensus level. + +Recovery steps: + 1. Calls /recover to try P2P sync + 2. Calls /mineBlock to force block production + 3. Waits for in-process force finalization if enabled in config + 4. Removes up to maxLeaders*2 blocks as last resort + +Note: If forceFinalize is enabled, the node auto-resolves block conflicts. + This script is only needed when no leader produces blocks at all, + when force finalization is not enabled, or when it fails. + +Usage: + ./scripts/auto_resolve_halt.sh [options] + +Options: + --check Only check if chain is halted (exit 1 if halted) + --recover Run recovery steps but do NOT truncate blocks + --force-remove=N Remove N blocks and restart (skip detection) + --dry-run Show what would be done without making changes + --help Show this help + +Environment variables: + HTTP_PORT HTTP API port (default: 3001) + HTTP_HOST HTTP API host (default: 0.0.0.0) + HALT_TIMEOUT_SEC Seconds before considering chain halted (default: 30) + MAX_REMOVE_BLOCKS Max blocks to remove per truncation (default: 10) + MAX_TOTAL_REMOVE Cumulative cap on total blocks removed (default: MAX_REMOVE_BLOCKS*3) + HALT_STATE_DIR Directory for truncation state tracking (default: .avalon_halt) + BLOCKS_DIR BSON blocks directory (if using BSON storage) + DB_NAME MongoDB database name (default: avalon) + DB_URL MongoDB URL (default: mongodb://localhost:27017) + NODE_OWNER Your node owner name (for /mineBlock) + DRY_RUN Set to 1 for dry-run mode (default: 0) + +Config note: If node config has forceFinalize=true, the script will + automatically wait for the in-process force finalization timeout + (blockTime * (leaders + consensusRounds + 2) ms + 10s margin) + before proceeding to block truncation. +EOF +} + +do_check() { + if check_halt; then + info "Chain is running normally" + exit 0 + else + local rc=$? + if [ "$rc" = "2" ]; then + info "Cannot determine chain status (node may be offline)" + exit 2 + fi + info "Chain is halted" + exit 1 + fi +} + +do_recover() { + info "=== Recovery Mode ===" + if ! is_node_running; then + err "Node is not running, start it first" + exit 1 + fi + + local halt_rc=0 + check_halt || halt_rc=$? + + if [ "$halt_rc" = "2" ]; then + exit 1 + fi + + try_recover && exit 0 + try_mine_block && exit 0 + + info "Recovery steps completed, chain still halted." + info "Use --force-remove=N or run without flags to truncate blocks." + exit 1 +} + +do_force_remove() { + local remove_count="$1" + + if ! [[ "$remove_count" =~ ^[0-9]+$ ]] || [ "$remove_count" -le 0 ]; then + err "Invalid block count: $remove_count" + exit 1 + fi + + info "=== Force Remove Mode: removing $remove_count blocks ===" + + # Get current height before stopping + local current_height=0 + if is_node_running; then + local block_json + block_json=$(get_latest_block) || true + if [ -n "$block_json" ]; then + current_height=$(echo "$block_json" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const b=JSON.parse(d);console.log(b._id)})") + fi + fi + + # Safety check (enforced even when node is offline) + if [ "$current_height" -gt 0 ]; then + check_truncation_safety "$current_height" "$remove_count" || exit 1 + else + check_truncation_safety 0 "$remove_count" || exit 1 + fi + + stop_node + + local new_height=0 + if [ -n "$BLOCKS_DIR" ]; then + new_height=$(truncate_blocks_bson "$remove_count") + else + new_height=$(truncate_blocks_mongo "$remove_count") + fi + + if [ -n "$new_height" ]; then + update_state_after_truncation "$new_height" "$remove_count" + fi + + cleanup_mongodb_state "$new_height" + start_node_with_rebuild +} + +do_auto_resolve() { + info "=== Auto-Resolve Halt ===" + + if ! is_node_running; then + info "Node not running. Use --force-remove=N to truncate and start." + exit 1 + fi + + check_halt || true + local rc=$? + if [ "$rc" = "2" ]; then + exit 1 + fi + if [ "$rc" = "0" ]; then + info "No action needed." + exit 0 + fi + + # Chain is halted, try recovery steps + try_recover && exit 0 + try_mine_block && exit 0 + + # Still halted — check if force finalization can resolve conflicts in-process + info "Step 3: /recover and /mineBlock failed — checking force finalization..." + + local cfg + cfg=$(get_config) || true + if [ -n "$cfg" ]; then + if wait_force_finalize "$cfg"; then + info "Halt resolved via force finalization" + exit 0 + fi + else + warn "Cannot fetch config, skipping forceFinalize wait" + fi + + info "Step 4: Force finalization did not resolve halt — preparing block truncation..." + + cfg=$(get_config) || { + warn "Cannot fetch config, using defaults: leaders=5, blockTime=3000" + local leaders=5 + local block_time=3000 + } + if [ -n "$cfg" ]; then + leaders=$(echo "$cfg" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.parse(d).leaders||5))") + block_time=$(echo "$cfg" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.parse(d).blockTime||3000))") + fi + + local max_remove=$(( leaders * 2 )) + # Use user-configured max if smaller + [ "$MAX_REMOVE_BLOCKS" -lt "$max_remove" ] && max_remove="$MAX_REMOVE_BLOCKS" + + info "Config: leaders=$leaders, blockTime=${block_time}ms, maxRemove=$max_remove" + + # Calculate halt duration in blocks + local block_json + block_json=$(get_latest_block) || true + local latest_height=0 latest_ts=0 + if [ -n "$block_json" ]; then + latest_height=$(echo "$block_json" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const b=JSON.parse(d);console.log(b._id)})") + latest_ts=$(echo "$block_json" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const b=JSON.parse(d);console.log(b.timestamp)})") + fi + local now_ms + now_ms=$(date +%s%3N) + local halt_ms=$(( now_ms - latest_ts )) + local halt_blocks=$(( halt_ms / block_time )) + + # Remove up to max_remove, but at least 1 (if truly halted) + local to_remove=$(( halt_blocks > max_remove ? max_remove : halt_blocks )) + [ "$to_remove" -lt 1 ] && to_remove=1 + + info "Halt duration: ~${halt_blocks} blocks, removing ${to_remove}" + + # Safety check: prevent repeated truncation from wiping the chain + check_truncation_safety "$latest_height" "$to_remove" || exit 1 + + stop_node + + local new_height=0 + if [ -n "$BLOCKS_DIR" ]; then + new_height=$(truncate_blocks_bson "$to_remove") + else + new_height=$(truncate_blocks_mongo "$to_remove") + fi + + if [ -n "$new_height" ]; then + update_state_after_truncation "$new_height" "$to_remove" + fi + + cleanup_mongodb_state "$new_height" + start_node_with_rebuild +} + +# === Parse arguments === +MODE="auto" +FORCE_REMOVE="" + +while [ $# -gt 0 ]; do + case "$1" in + --help|-h) + show_help + exit 0 + ;; + --check) + MODE="check" + ;; + --recover) + MODE="recover" + ;; + --force-remove=*) + MODE="force_remove" + FORCE_REMOVE="${1#*=}" + ;; + --force-remove) + MODE="force_remove" + FORCE_REMOVE="$2" + shift + ;; + --dry-run) + DRY_RUN=1 + ;; + *) + err "Unknown option: $1" + show_help + exit 1 + ;; + esac + shift +done + +case "$MODE" in + check) do_check ;; + recover) do_recover ;; + force_remove) do_force_remove "$FORCE_REMOVE" ;; + auto) do_auto_resolve ;; +esac diff --git a/scripts/start_test_node.sh b/scripts/start_test_node.sh new file mode 100644 index 0000000..5691cf1 --- /dev/null +++ b/scripts/start_test_node.sh @@ -0,0 +1,22 @@ +#!/bin/bash +# Start Avalon test node for integration testing +# Uses the existing MongoDB on the host, separate DB, different port + +export HTTP_PORT=3029 +export P2P_PORT=6029 +export DB_NAME=avalon_2 +export DB_URL=mongodb://localhost:27017 +export NODE_OWNER=dtube +export NODE_OWNER_PUB=dTuBhkU6SUx9JEx1f4YEt34X9sC7QGso2dSrqE8eJyfz +export NODE_OWNER_PRIV=34EpMEDFJwKbxaF7FhhLyEe3AhpM4dwHMLVfs4JyRto5 +export OFFLINE=1 +export LOG_LEVEL=debug +export WARMUP_ACCOUNTS=0 +export WARMUP_CONTENTS=0 +export NO_DISCOVERY=1 +export REPLAY_OUTPUT=0 +export NODE_OPTIONS="--max-old-space-size=4096" +export MINE_TOKEN=test-mine-token-123 +export DEBUG_TOKEN=test-debug-token-456 + +exec node --stack-size=65500 src/main.js "$@" diff --git a/scripts/test_secp256k1.js b/scripts/test_secp256k1.js index 79716bf..6c77f9b 100644 --- a/scripts/test_secp256k1.js +++ b/scripts/test_secp256k1.js @@ -1,7 +1,7 @@ const randomBytes = require('randombytes') const secp256k1 = require('secp256k1') const bs58 = require('bs58') -var CryptoJS = require('crypto-js') +const crypto = require('crypto') const { performance } = require('perf_hooks') const iterations = parseInt(process.argv[2]) @@ -44,7 +44,7 @@ function sign(privKey, sender, tx) { // add timestamp to seed the hash (avoid transactions reuse) tx.ts = new Date().getTime() // hash the transaction - tx.hash = CryptoJS.SHA256(JSON.stringify(tx)).toString() + tx.hash = crypto.createHash('sha256').update(JSON.stringify(tx)).digest('hex') // sign the transaction var signature = secp256k1.ecdsaSign(Buffer.from(tx.hash, 'hex'), bs58.decode(privKey)) tx.signature = bs58.encode(signature.signature) diff --git a/src/blocks.js b/src/blocks.js index 1813f2d..218dd3f 100644 --- a/src/blocks.js +++ b/src/blocks.js @@ -1,5 +1,4 @@ const fs = require('fs') -const assert = require('assert') const BSON = require('bson') const logr = require('./logger') const mongo = require('./mongo') @@ -13,6 +12,7 @@ let blocks = { dataDir: process.env.BLOCKS_DIR ? process.env.BLOCKS_DIR.replace(/\/$/,''): '', isOpen: false, notOpenError: 'Blockchain is not open', + maxDocSize: () => Math.min(512*1024*1024, Math.max(10*1024*1024, (config.maxTxPerBlock || 200) * (config.jsonMaxBytes || 60000) * 4)), init: async (state) => { if (!process.env.BLOCKS_DIR) return @@ -44,20 +44,26 @@ let blocks = { blocks.isOpen = true // Determine if resumption of index creation is required - let resumeIndex = false if (indexSize > 0) { - assert(indexSize % 8 === 0, 'Size of index file should be in multiple of 8') + if (indexSize % 8 !== 0) { + logr.fatal('Corrupted index file at ' + indexPath + ': size ' + indexSize + ' is not multiple of 8') + blocks.close() + process.exit(1) + } let docPosition = BigInt(0) let docSizeBuf = Buffer.alloc(4) let docIndexBuf = Buffer.alloc(8) fs.readSync(blocks.fdIndex,docIndexBuf,{offset: 0, position: indexSize-8, length: 8}) docPosition = BigInt(Number(BigInt(docIndexBuf.readUInt32LE(0)) << 8n) + docIndexBuf.readUInt32LE(4)) - assert(docPosition < blocks.bsonSize, 'Latest indexed position greater than or equal to blocks.bson size') + if (docPosition >= blocks.bsonSize) { + logr.fatal('Indexed position ' + docPosition + ' exceeds blocks.bson size ' + blocks.bsonSize) + blocks.close() + process.exit(1) + } fs.readSync(blocks.fd,docSizeBuf,{offset: 0, position: docPosition, length: 4}) let docSize = BigInt(docSizeBuf.readInt32LE(0)) docPosition += docSize if (docPosition < blocks.bsonSize) { - resumeIndex = true logr.info('Resuming index creation from block',blocks.height) blocks.reconstructIndex(docSizeBuf,docPosition,blocks.height+1) } @@ -94,14 +100,14 @@ let blocks = { }, touch: () => { let bsonPath = blocks.dataDir+'/blocks.bson' - let indexPath = blocks.dataDir+'/blocks.bson' + let indexPath = blocks.dataDir+'/blocks.index' if (!fs.existsSync(bsonPath)) fs.closeSync(fs.openSync(bsonPath,'w')) if (!fs.existsSync(indexPath)) fs.closeSync(fs.openSync(indexPath,'w')) }, reconstructIndex: (currentDocSizeBuf, currentDocPosition, currentBlockHeight) => { - assert(blocks.isOpen,blocks.notOpenError) + if (!blocks.isOpen) { logr.fatal(blocks.notOpenError); process.exit(1) } logr.info('Reconstructing blocks BSON index file...') let startTime = new Date().getTime() @@ -122,8 +128,8 @@ let blocks = { logr.info('Index reconstructed up to block #'+blocks.height+' in '+(new Date().getTime()-startTime)+'ms') }, appendBlock: (newBlock) => { - assert(blocks.isOpen,blocks.notOpenError) - assert(newBlock._id === blocks.height+1,'could not append non-next block') + if (!blocks.isOpen) { logr.fatal(blocks.notOpenError); process.exit(1) } + if (newBlock._id !== blocks.height+1) { logr.fatal('could not append non-next block: expected ' + (blocks.height+1) + ' got ' + newBlock._id); process.exit(1) } let serializedBlock = BSON.serialize(newBlock) let newBlockSize = BigInt(serializedBlock.length) fs.writeSync(blocks.fd,serializedBlock) @@ -132,7 +138,7 @@ let blocks = { blocks.height++ }, appendIndex: (pos) => { - assert(blocks.isOpen,blocks.notOpenError) + if (!blocks.isOpen) { logr.fatal(blocks.notOpenError); process.exit(1) } let indexBuf = Buffer.alloc(8) indexBuf.writeUInt32LE(Number(pos >> 8n), 0) indexBuf.writeUInt32LE(Number(pos & 0xFFn), 4) @@ -150,15 +156,22 @@ let blocks = { let indexBuf = Buffer.alloc(8) fs.readSync(blocks.fdIndex,indexBuf,{offset: 0, position: blockNum*8, length: 8}) let docPosition = Number(BigInt(indexBuf.readUInt32LE(0)) << 8n) + indexBuf.readUInt32LE(4) - assert(BigInt(docPosition) < blocks.bsonSize,'Bson position out of range') + if (BigInt(docPosition) >= blocks.bsonSize) + throw new Error('Bson position ' + docPosition + ' out of range (size ' + blocks.bsonSize + ')') // Read blocks BSON at position of block let docSizeBuf = Buffer.alloc(4) fs.readSync(blocks.fd,docSizeBuf,{offset: 0, position: docPosition, length: 4}) let docSize = docSizeBuf.readInt32LE(0) + if (docSize < 1 || docSize > blocks.maxDocSize()) + throw new Error('Invalid BSON doc size ' + docSize + ' at position ' + docPosition) let docBuf = Buffer.alloc(docSize) fs.readSync(blocks.fd,docBuf,{offset: 0, position: docPosition, length: docSize}) - return BSON.deserialize(docBuf) + try { + return BSON.deserialize(docBuf) + } catch (e) { + throw new Error('Failed to deserialize block #' + blockNum + ': ' + e.message) + } }, readRange: (start,end) => { if (!blocks.isOpen) @@ -183,21 +196,34 @@ let blocks = { fs.readSync(blocks.fdIndex,indexBufEnd,{offset: 0, position: end*8, length: 8}) let docPosition = Number(BigInt(indexBuf.readUInt32LE(0)) << 8n) + indexBuf.readUInt32LE(4) let docPositionEnd = Number(BigInt(indexBufEnd.readUInt32LE(0)) << 8n) + indexBufEnd.readUInt32LE(4) - assert(BigInt(docPosition) < blocks.bsonSize && BigInt(docPositionEnd) < blocks.bsonSize,'Bson position out of range') + if (BigInt(docPosition) >= blocks.bsonSize || BigInt(docPositionEnd) >= blocks.bsonSize) + throw new Error('Bson position out of range in readRange') + // Read blocks BSON from start position to end position of last block let docSizeBufEnd = Buffer.alloc(4) fs.readSync(blocks.fd,docSizeBufEnd,{offset: 0, position: docPositionEnd, length: 4}) let docSizeEnd = docSizeBufEnd.readInt32LE(0) + if (docSizeEnd < 1 || docSizeEnd > blocks.maxDocSize()) + throw new Error('Invalid BSON doc size in readRange: ' + docSizeEnd) let rangeSize = docPositionEnd-docPosition+docSizeEnd + if (rangeSize < 1 || rangeSize > 2*1024*1024*1024) + throw new Error('Read range too large: ' + rangeSize + ' bytes') let docBuf = Buffer.alloc(rangeSize) let docArr = [] fs.readSync(blocks.fd,docBuf,{offset: 0, position: docPosition, length: rangeSize}) - BSON.deserializeStream(docBuf,0,end-start+1,docArr,0) + try { + BSON.deserializeStream(docBuf,0,end-start+1,docArr,0) + } catch (e) { + throw new Error('Failed to deserialize blocks ' + start + '-' + end + ': ' + e.message) + } return docArr }, fillInMemoryBlocks: (headBlock = blocks.height+1) => { - assert(blocks.isOpen,blocks.notOpenError) + if (!blocks.isOpen) { + logr.fatal(blocks.notOpenError) + process.exit(1) + } let end = headBlock-1 let start = end - (config.ecoBlocksIncreasesSoon ? config.ecoBlocksIncreasesSoon : config.ecoBlocks) + 1 chain.recentBlocks = blocks.readRange(start,end) diff --git a/src/cache.js b/src/cache.js index ee27074..9c8559e 100644 --- a/src/cache.js +++ b/src/cache.js @@ -46,7 +46,7 @@ let cache = { cache.inserts = [] // reset leader changes - for (let i in cache.leaderChanges) + for (let i = 0; i < cache.leaderChanges.length; i++) if (cache.leaderChanges[i][1] === 0) cache.addLeader(cache.leaderChanges[i][0],true,()=>{}) else if (cache.leaderChanges[i][1] === 1) @@ -59,13 +59,20 @@ let cache = { findOnePromise: function(collection, query, skipClone) { return new Promise((rs,rj) => cache.findOne(collection,query,(e,d) => e ? rj(e) : rs(d),skipClone)) }, + sanitizeQuery: function(query) { + if (!query || typeof query !== 'object' || Array.isArray(query)) return + for (const k of Object.keys(query)) + if (k === '__proto__' || k === 'constructor' || k === 'prototype') + delete query[k] + }, findOne: function(collection, query, cb, skipClone) { if (!cache.copy[collection]) return cb('invalid collection') + cache.sanitizeQuery(query) let key = cache.keyByCollection(collection) // searching in cache - if (cache[collection][query[key]]) { + if (query && cache[collection][query[key]]) { if (!skipClone) cb(null, cloneDeep(cache[collection][query[key]])) else @@ -74,7 +81,9 @@ let cache = { } // no match, searching in mongodb - db.collection(collection).findOne(query, function(err, obj) { + let sanitizedQuery = {} + sanitizedQuery[key] = query[key] + db.collection(collection).findOne(sanitizedQuery, function(err, obj) { if (err) logr.debug('error cache') else { if (!obj) { @@ -93,9 +102,10 @@ let cache = { }) }, updateOnePromise: function (collection, query, changes) { - return new Promise((rs,rj) => cache.updateOne(collection,query,changes,(e,d) => e ? rj(e) : rs(true))) + return new Promise((rs,rj) => cache.updateOne(collection,query,changes,(e) => e ? rj(e) : rs(true))) }, updateOne: function(collection, query, changes, cb) { + cache.sanitizeQuery(query) cache.findOne(collection, query, function(err, obj) { if (err) throw err if (!obj) { @@ -106,7 +116,8 @@ let cache = { if (!cache.copy[collection][obj[key]] && (!chain.restoredBlocks || chain.getLatestBlock()._id >= chain.restoredBlocks)) cache.copy[collection][obj[key]] = cloneDeep(cache[collection][obj[key]]) - for (let c in changes) + for (let c in changes) { + if (c === '__proto__' || c === 'constructor' || c === 'prototype') continue switch (c) { case '$inc': for (let i in changes[c]) @@ -157,6 +168,7 @@ let cache = { default: break } + } cache.changes.push({ collection: collection, @@ -253,7 +265,7 @@ let cache = { // if (cache.changes.length) logr.debug(cache.changes.length+' Updates compressed to '+Object.keys(docsToUpdate.accounts).length+' accounts, '+Object.keys(docsToUpdate.contents).length+' contents') for (const col in docsToUpdate) - for (const i in docsToUpdate[col]) + Object.keys(docsToUpdate[col]).forEach(i => { executions.push(function(callback) { let key = cache.keyByCollection(col) let newDoc = docsToUpdate[col][i] @@ -264,18 +276,19 @@ let cache = { callback() }) }) + }) // leader stats if (process.env.LEADER_STATS === '1') { let leaderStatsWriteOps = leaderStats.getWriteOps() - for (let op in leaderStatsWriteOps) + for (let op = 0; op < leaderStatsWriteOps.length; op++) executions.push(leaderStatsWriteOps[op]) } // tx history if (process.env.TX_HISTORY === '1') { let txHistoryWriteOps = txHistory.getWriteOps() - for (let op in txHistoryWriteOps) + for (let op = 0; op < txHistoryWriteOps.length; op++) executions.push(txHistoryWriteOps[op]) } @@ -295,14 +308,17 @@ let cache = { }) } else { logr.debug(executions.length+' mongo ops queued') - cache.writerQueue.push((callback) => parallel(executions,() => callback())) + cache.writerQueue.push((callback) => parallel(executions,(err) => { + if (err) logr.error('mongo write queue error', err) + callback(err) + })) cache.clear() } }, processRebuildOps: (cb,writeToDisk) => { - for (let i in cache.inserts) + for (let i = 0; i < cache.inserts.length; i++) cache.rebuild.inserts.push(cache.inserts[i]) - for (let i in cache.changes) + for (let i = 0; i < cache.changes.length; i++) cache.rebuild.changes.push(cache.changes[i]) cache.inserts = [] cache.changes = [] @@ -364,7 +380,7 @@ let cache = { ] }).toArray((e,accs) => { if (e) throw e - for (let i in accs) { + for (let i = 0; i < accs.length; i++) { cache.leaders[accs[i].name] = 1 if (!cache.accounts[accs[i].name]) cache.accounts[accs[i].name] = accs[i] diff --git a/src/chain.js b/src/chain.js index 5088299..a4f9f4b 100644 --- a/src/chain.js +++ b/src/chain.js @@ -1,5 +1,5 @@ -const CryptoJS = require('crypto-js') -const { randomBytes } = require('crypto') +const crypto = require('crypto') +const { randomBytes } = crypto const secp256k1 = require('secp256k1') const bs58 = require('base-x')(config.b58Alphabet) const series = require('run-series') @@ -13,7 +13,9 @@ const blocks = require('./blocks') const GrowInt = require('growint') const default_replay_output = 100 const replay_output = process.env.REPLAY_OUTPUT || default_replay_output -const skip_check_early_blocks = [3889058] // to be removed in case of a fork or new net. +// Temporal check bypass for specific block heights during migrations/forks. +// Set via env: SKIP_EARLY_CHECK_BLOCKS=3889058,4000000 +const skip_check_early_blocks = (process.env.SKIP_EARLY_CHECK_BLOCKS || '3889058').split(',').map(Number) const max_batch_blocks = 10000 class Block { @@ -70,6 +72,8 @@ let chain = { // grab all transactions and sort by ts let txs = [] let mempool = transaction.pool.sort(function(a,b){return a.ts-b.ts}) + const maxPerSender = Math.max(1, Math.floor(config.maxTxPerBlock / 10)) + // pass 1: at most 1 tx per unique sender (fairness) loopOne: for (let i = 0; i < mempool.length; i++) { if (txs.length === config.maxTxPerBlock) @@ -80,6 +84,8 @@ let chain = { txs.push(mempool[i]) } + // pass 2: fill remaining slots with a per-sender cap + const senderCounts = {} loopTwo: for (let i = 0; i < mempool.length; i++) { if (txs.length === config.maxTxPerBlock) @@ -87,6 +93,10 @@ let chain = { for (let y = 0; y < txs.length; y++) if (txs[y].hash === mempool[i].hash) continue loopTwo + const sender = mempool[i].sender || 'unknown' + senderCounts[sender] = (senderCounts[sender] || 0) + 1 + if (senderCounts[sender] > maxPerSender) + continue loopTwo txs.push(mempool[i]) } txs = txs.sort(function(a,b){return a.ts-b.ts}) @@ -153,6 +163,8 @@ let chain = { possBlock[0].push(process.env.NODE_OWNER) consensus.possBlocks.push(possBlock) + if (config.forceFinalize) + consensus.scheduleForceFinalize() consensus.endRound(0, newBlock) cb(null, newBlock) }) @@ -162,9 +174,9 @@ let chain = { // when we receive an outside block and check whether we should add it to our chain or not if (chain.shuttingDown) return chain.isValidNewBlock(newBlock, revalidate, false, function(isValid) { - if (!isValid) { + if (!isValid) return cb(true, newBlock) - } + // straight execution chain.executeBlockTransactions(newBlock, revalidate, function(validTxs, distributed, burned) { // if any transaction is wrong, thats a fatal error @@ -210,7 +222,7 @@ let chain = { }) }, addRecentTxsInBlock: (txs = []) => { - for (let t in txs) + for (let t = 0; t < txs.length; t++) chain.recentTxs[txs[t].hash] = txs[t] }, minerWorker: (block) => { @@ -263,8 +275,12 @@ let chain = { // push cached accounts and contents to mongodb chain.cleanMemory() - // update the config if an update was scheduled - config = require('./config.js').read(block._id) + // update the config if an update was scheduled (remove stale keys) + const freshConfig = require('./config.js').read(block._id) + for (const k of Object.keys(config)) + if (!(k in freshConfig)) + delete config[k] + Object.assign(config, freshConfig) chain.applyHardforkPostBlock(block._id) eco.appendHistory(block) eco.nextBlock() @@ -300,7 +316,8 @@ let chain = { if (rebuilding) output += '/' + chain.restoredBlocks else - output += ' by '+block.miner + // eslint-disable-next-line no-control-regex + output += ' by '+(block.miner||'').replace(/[\x00-\x1f]/g, '') output += ' '+chain.nextOutput.txs+' tx' if (chain.nextOutput.txs>1) @@ -342,81 +359,92 @@ let chain = { isValidSignature: (user, txType, hash, sign, cb) => { // verify signature and bandwidth cache.findOne('accounts', {name: user}, async function(err, account) { - if (err) throw err - if (!account) { - cb(false); return - } else if (chain.restoredBlocks && chain.getLatestBlock()._id < chain.restoredBlocks && process.env.REBUILD_NO_VERIFY === '1') + try { + if (err) throw err + if (!account) { + cb(false); return + } else if (chain.restoredBlocks && chain.getLatestBlock()._id < chain.restoredBlocks && process.env.REBUILD_NO_VERIFY === '1') // no verify rebuild mode, only use if you trust the contents of blocks.zip - return cb(account) - - // main key can authorize all transactions - let allowedPubKeys = [[account.pub, account.pub_weight || 1]] - let threshold = 1 - // add all secondary keys having this transaction type as allowed keys - if (account.keys && typeof txType === 'number' && Number.isInteger(txType)) - for (let i = 0; i < account.keys.length; i++) - if (account.keys[i].types.indexOf(txType) > -1) - allowedPubKeys.push([account.keys[i].pub, account.keys[i].weight || 1]) - // account authorities - if (account.auths && typeof txType === 'number' && Number.isInteger(txType)) - for (let i in account.auths) - if (account.auths[i].types.indexOf(txType) > -1) { - let authorizedAcc = await cache.findOnePromise('accounts',{name: account.auths[i].user}) - if (authorizedAcc && authorizedAcc.keys) - for (let a in authorizedAcc.keys) - if (authorizedAcc.keys[a].id === account.auths[i].id) { - allowedPubKeys.push([authorizedAcc.keys[a].pub, account.auths[i].weight || 1]) - break - } - } + return cb(account) + + // main key can authorize all transactions + let allowedPubKeys = [[account.pub, account.pub_weight || 1]] + let threshold = 1 + // add all secondary keys having this transaction type as allowed keys + if (account.keys && typeof txType === 'number' && Number.isInteger(txType)) + for (let i = 0; i < account.keys.length; i++) + if (account.keys[i].types.indexOf(txType) > -1) + allowedPubKeys.push([account.keys[i].pub, account.keys[i].weight || 1]) + // account authorities + if (account.auths && Array.isArray(account.auths) && typeof txType === 'number' && Number.isInteger(txType)) + for (let i = 0; i < account.auths.length; i++) + if (account.auths[i].types.indexOf(txType) > -1) { + let authorizedAcc = await cache.findOnePromise('accounts',{name: account.auths[i].user}) + if (authorizedAcc && authorizedAcc.keys && Array.isArray(authorizedAcc.keys)) + for (let a = 0; a < authorizedAcc.keys.length; a++) + if (authorizedAcc.keys[a].id === account.auths[i].id) { + allowedPubKeys.push([authorizedAcc.keys[a].pub, account.auths[i].weight || 1]) + break + } + } - // if there is no transaction type - // it means we are verifying a block signature - // so only the leader key is allowed - if (txType === null) - if (account.pub_leader) - allowedPubKeys = [[account.pub_leader, 1]] - else - allowedPubKeys = [] - // compute required signature threshold otherwise - else if (account.thresholds && account.thresholds[txType]) - threshold = account.thresholds[txType] - else if (account.thresholds && account.thresholds.default) - threshold = account.thresholds.default - - // multisig transactions - if (config.multisig && Array.isArray(sign)) - return chain.isValidMultisig(account,threshold,allowedPubKeys,hash,sign,cb) + // if there is no transaction type + // it means we are verifying a block signature + // so only the leader key is allowed + if (txType === null) + if (account.pub_leader) + allowedPubKeys = [[account.pub_leader, 1]] + else + allowedPubKeys = [] + // compute required signature threshold otherwise + else if (account.thresholds && account.thresholds[txType]) + threshold = account.thresholds[txType] + else if (account.thresholds && account.thresholds.default) + threshold = account.thresholds.default + + // multisig transactions + if (config.multisig && Array.isArray(sign)) + return chain.isValidMultisig(account,threshold,allowedPubKeys,hash,sign,cb) - // single signature - try { - for (let i = 0; i < allowedPubKeys.length; i++) { - let bufferHash = Buffer.from(hash, 'hex') - let b58sign = bs58.decode(sign) - let b58pub = bs58.decode(allowedPubKeys[i][0]) - if (secp256k1.ecdsaVerify(b58sign, bufferHash, b58pub) && allowedPubKeys[i][1] >= threshold) { - cb(account) - return + // single signature + try { + for (let i = 0; i < allowedPubKeys.length; i++) { + let bufferHash = Buffer.from(hash, 'hex') + let b58sign = bs58.decode(sign) + let b58pub = bs58.decode(allowedPubKeys[i][0]) + if (secp256k1.ecdsaVerify(b58sign, bufferHash, b58pub) && allowedPubKeys[i][1] >= threshold) { + cb(account) + return + } } - } - } catch (e) {} - cb(false) + } catch (e) {} + cb(false) + } catch (e) { + logr.error('Unhandled error in isValidSignature', e) + cb(false) + } }) }, isValidMultisig: (account,threshold,allowedPubKeys,hash,signatures,cb) => { + if (!Array.isArray(signatures) || signatures.length > 50) + return cb(false, 'invalid signature count') + let validWeights = 0 - let validSigs = [] + let validSigSet = new Set() try { + let allowedPubSet = {} + for (let p = 0; p < allowedPubKeys.length; p++) + allowedPubSet[allowedPubKeys[p][0]] = true let hashBuf = Buffer.from(hash, 'hex') for (let s = 0; s < signatures.length; s++) { let signBuf = bs58.decode(signatures[s][0]) let recoveredPub = bs58.encode(secp256k1.ecdsaRecover(signBuf,signatures[s][1],hashBuf)) - if (validSigs.includes(recoveredPub)) - return cb(false, 'duplicate signatures found') + if (!allowedPubSet[recoveredPub] || validSigSet.has(recoveredPub)) + continue for (let p = 0; p < allowedPubKeys.length; p++) if (allowedPubKeys[p][0] === recoveredPub) { validWeights += allowedPubKeys[p][1] - validSigs.push(recoveredPub) + validSigSet.add(recoveredPub) } } } catch (e) { @@ -536,7 +564,7 @@ let chain = { // to mine after (n+1)*blockTime as 'backups' // so that the network can keep going even if 1,2,3...n node(s) have issues else - for (let i = 1; i <= config.leaders; i++) { + for (let i = 1; i <= config.leaders; i++) if (chain.recentBlocks.length - i >= 0) { if (!chain.recentBlocks[chain.recentBlocks.length - i]) break @@ -545,7 +573,7 @@ let chain = { break } } - } + if (minerPriority === 0) { @@ -554,7 +582,7 @@ let chain = { } // check if new block isnt too early - if (newBlock.timestamp - previousBlock.timestamp < minerPriority*config.blockTime && skip_check_early_blocks.indexOf(newBlock._id) == -1) { + if (newBlock.timestamp - previousBlock.timestamp < minerPriority*config.blockTime && skip_check_early_blocks.indexOf(newBlock._id) === -1) { logr.error('block too early for miner with priority #'+minerPriority) cb(false); return } @@ -622,7 +650,6 @@ let chain = { burned: burned }) }) - i++ }) executions.push((callback) => chain.applyHardfork(block,callback)) @@ -685,6 +712,9 @@ let chain = { y++ } + // reset observer flag so nodes can re-evaluate their active status + consensus.observer = false + return { block: block, shuffle: shuffledMiners @@ -693,11 +723,12 @@ let chain = { generateLeaders: (withLeaderPub, withWs, limit, start) => { let leaders = [] let leaderAccs = withLeaderPub ? cache.leaders : cache.accounts - for (const key in leaderAccs) { - if (!cache.accounts[key].node_appr || cache.accounts[key].node_appr <= 0) - continue + Object.keys(leaderAccs).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(leaderAccs, key)) return + if (!cache.accounts[key] || !cache.accounts[key].node_appr || cache.accounts[key].node_appr <= 0) + return if (withLeaderPub && !cache.accounts[key].pub_leader) - continue + return let leader = cache.accounts[key] let leaderDetails = { name: leader.name, @@ -710,7 +741,7 @@ let chain = { if (withWs && leader.json && leader.json.node && typeof leader.json.node.ws === 'string') leaderDetails.ws = leader.json.node.ws leaders.push(leaderDetails) - } + }) leaders = leaders.sort(function(a,b) { return b.node_appr - a.node_appr }) @@ -788,7 +819,7 @@ let chain = { delete clonedBlock.hash delete clonedBlock.signature } - return CryptoJS.SHA256(JSON.stringify(deleteExisting ? clonedBlock : block)).toString() + return crypto.createHash('sha256').update(JSON.stringify(deleteExisting ? clonedBlock : block)).digest('hex') } }, calculateHashV1: (index, phash, timestamp, txs, miner, missedBy, distributed, burned) => { @@ -797,7 +828,7 @@ let chain = { if (distributed) string += distributed if (burned) string += burned - return CryptoJS.SHA256(string).toString() + return crypto.createHash('sha256').update(string).digest('hex') }, getLatestBlock: () => { return chain.recentBlocks[chain.recentBlocks.length-1] @@ -813,6 +844,13 @@ let chain = { cleanMemoryBlocks: () => { if (config.ecoBlocksIncreasesSoon) { logr.trace('Keeping old blocks in memory because ecoBlocks is changing soon') + if (chain.recentBlocks.length > config.ecoBlocks * 2) { + let overflow = chain.recentBlocks.length - config.ecoBlocks * 2 + while (overflow > 0) { + chain.recentBlocks.shift() + overflow-- + } + } return } @@ -823,9 +861,10 @@ let chain = { } }, cleanMemoryTx: () => { - for (const hash in chain.recentTxs) + Object.keys(chain.recentTxs).forEach(hash => { if (chain.recentTxs[hash].ts + config.txExpirationTime < chain.getLatestBlock().timestamp) delete chain.recentTxs[hash] + }) }, applyHardfork: (block,cb) => { // Do something on hardfork block after tx executions and before leader rewards distribution @@ -889,9 +928,9 @@ let chain = { if (!isValidBlock) return cb(true, blockNum) } - chain.executeBlockTransactions(blockToRebuild,process.env.REBUILD_NO_VALIDATE !== '1',(validTxs,dist,burn) => { + chain.executeBlockTransactions(blockToRebuild,false,(validTxs,dist,burn) => { // if any transaction is wrong, thats a fatal error - // transactions should have been verified in isValidNewBlock + // matching consensus validation: skip revalidation, trust miner if (blockToRebuild.txs.length !== validTxs.length) { logr.fatal('Invalid tx(s) in block found after starting execution') return cb('Invalid tx(s) in block found after starting execution', blockNum) @@ -908,7 +947,7 @@ let chain = { // update the config if an update was scheduled chain.addRecentTxsInBlock(blockToRebuild.txs) - config = require('./config.js').read(blockToRebuild._id) + Object.assign(config, require('./config.js').read(blockToRebuild._id)) chain.applyHardforkPostBlock(blockToRebuild._id) dao.nextBlock() daoMaster.nextBlock() diff --git a/src/clicmds.js b/src/clicmds.js index 79910b4..da03f5b 100644 --- a/src/clicmds.js +++ b/src/clicmds.js @@ -1,5 +1,5 @@ let config = require('./config.js').read(0) -const CryptoJS = require('crypto-js') +const crypto = require('crypto') const secp256k1 = require('secp256k1') const bs58 = require('base-x')(config.b58Alphabet) //const bs58 = require('bs58') @@ -12,7 +12,7 @@ let sign = (privKey, sender, tx) => { let txString = JSON.stringify(tx) // hash the transaction - tx.hash = CryptoJS.SHA256(txString).toString() + tx.hash = crypto.createHash('sha256').update(txString).digest('hex') // decode the key let rawPriv = bs58.decode(privKey) @@ -31,238 +31,208 @@ let cmds = { }, createAccount: (privKey, sender, pub, name) => { - let tx = '{"type":0,"data":{"pub":"'+pub+'","name":"'+name+'"}}' - return sign(privKey, sender, tx) - }, + let tx = {type: 0, data: {pub, name}} + return sign(privKey, sender, JSON.stringify(tx)) + }, approveNode: (privKey, sender, nodeName) => { - let tx = '{"type":1,"data":{"target":"'+ nodeName +'"}}' - return sign(privKey, sender, tx) - }, - + let tx = {type: 1, data: {target: nodeName}} + return sign(privKey, sender, JSON.stringify(tx)) + }, + disapproveNode: (privKey, sender, nodeName) => { - let tx = '{"type":2,"data":{"target":"'+ nodeName +'"}}' - return sign(privKey, sender, tx) + let tx = {type: 2, data: {target: nodeName}} + return sign(privKey, sender, JSON.stringify(tx)) }, transfer: (privKey, sender, receiver, amount, memo) => { if (!memo) memo='' - let tx = '{"type":3,"data":{"receiver":"'+ - receiver+'", "amount":'+ - parseInt(amount)+', "memo":"'+memo+'"}}' - return sign(privKey, sender, tx) + let tx = {type: 3, data: {receiver, amount: parseInt(amount), memo}} + return sign(privKey, sender, JSON.stringify(tx)) }, post: (privKey, sender, uri, content) => { - let tx = '{"type":4,"data":{"link":"'+ - uri+'","json":'+content+'}}' - return sign(privKey, sender, tx) + let tx = {type: 4, data: {link: uri, json: typeof content === 'string' ? JSON.parse(content) : content}} + return sign(privKey, sender, JSON.stringify(tx)) }, comment: (privKey, sender, uri, pa, pp, content, weight, tag) => { - let tx = '{"type":4,"data":{"link":"'+ - uri+'", "pa":"'+ - pa+'", "pp":"'+ - pp+'", "vt":'+ - parseInt(weight)+', "tag":"'+ - tag+'","json":'+content+'}}' - return sign(privKey, sender, tx) + let tx = {type: 4, data: {link: uri, pa, pp, vt: parseInt(weight), tag, json: typeof content === 'string' ? JSON.parse(content) : content}} + return sign(privKey, sender, JSON.stringify(tx)) }, vote: (privKey, sender, link, author, weight, tag) => { if (!tag) tag = '' - let tx = '{"type":5,"data":{"link":"'+ - link+'", "author":"'+ - author+'", "vt": '+ - parseInt(weight)+', "tag": "'+tag+'"}}' - return sign(privKey, sender, tx) + let tx = {type: 5, data: {link, author, vt: parseInt(weight), tag}} + return sign(privKey, sender, JSON.stringify(tx)) }, - + profile: (privKey, sender, content) => { - let tx = '{"type":6,"data":{"json":'+content+'}}' - return sign(privKey, sender, tx) + let tx = {type: 6, data: {json: typeof content === 'string' ? JSON.parse(content) : content}} + return sign(privKey, sender, JSON.stringify(tx)) }, - + follow: (privKey, sender, username) => { - let tx = '{"type":7,"data":{"target":"'+username+'"}}' - return sign(privKey, sender, tx) + let tx = {type: 7, data: {target: username}} + return sign(privKey, sender, JSON.stringify(tx)) }, - + unfollow: (privKey, sender, username) => { - let tx = '{"type":8,"data":{"target":"'+username+'"}}' - return sign(privKey, sender, tx) + let tx = {type: 8, data: {target: username}} + return sign(privKey, sender, JSON.stringify(tx)) }, - + newKey: (privKey, sender, id, pub, types) => { - let tx = '{"type":10,"data":{"id":"'+ - id+'","pub":"'+ - pub+'","types":'+types+'}}' - return sign(privKey, sender, tx) + let tx = {type: 10, data: {id, pub, types: typeof types === 'string' ? JSON.parse(types) : types}} + return sign(privKey, sender, JSON.stringify(tx)) }, - + removeKey: (privKey, sender, id) => { - let tx = '{"type":11,"data":{"id":"'+id+'"}}' - return sign(privKey, sender, tx) + let tx = {type: 11, data: {id}} + return sign(privKey, sender, JSON.stringify(tx)) }, - + changePassword: (privKey, sender, pub) => { - let tx = '{"type":12,"data":{"pub":"'+pub+'"}}' - return sign(privKey, sender, tx) + let tx = {type: 12, data: {pub}} + return sign(privKey, sender, JSON.stringify(tx)) }, - + promotedComment: (privKey, sender, uri, pa, pp, content, weight, tag, burn) => { - let tx = '{"type":13,"data":{"link":"'+ - uri+'", "pa":"'+ - pa+'", "pp":"'+ - pp+'", "vt":'+ - parseInt(weight)+', "tag":"'+ - tag+'","burn":'+burn+',"json":'+content+'}}' - return sign(privKey, sender, tx) + let tx = {type: 13, data: {link: uri, pa, pp, vt: parseInt(weight), tag, burn: parseInt(burn), json: typeof content === 'string' ? JSON.parse(content) : content}} + return sign(privKey, sender, JSON.stringify(tx)) }, transferVt: (privKey, sender, receiver, amount) => { - let tx = '{"type":14,"data":{"receiver":"'+ - receiver+'", "amount":'+ - parseInt(amount)+'}}' - return sign(privKey, sender, tx) + let tx = {type: 14, data: {receiver, amount: parseInt(amount)}} + return sign(privKey, sender, JSON.stringify(tx)) }, transferBw: (privKey, sender, receiver, amount) => { - let tx = '{"type":15,"data":{"receiver":"'+ - receiver+'", "amount":'+ - parseInt(amount)+'}}' - return sign(privKey, sender, tx) + let tx = {type: 15, data: {receiver, amount: parseInt(amount)}} + return sign(privKey, sender, JSON.stringify(tx)) }, limitVt: (privKey, sender, amount) => { amount = parseInt(amount) if (amount === -1) amount = null - let tx = '{"type":16,"data":{"amount":'+ - amount+'}}' - return sign(privKey, sender, tx) + let tx = {type: 16, data: {amount}} + return sign(privKey, sender, JSON.stringify(tx)) }, claimReward: (privKey, sender, author, link) => { - let tx = '{"type":17,"data":{"author":"'+ - author+'", "link": "'+link+'"}}' - return sign(privKey, sender, tx) + let tx = {type: 17, data: {author, link}} + return sign(privKey, sender, JSON.stringify(tx)) }, enableNode: (privKey, sender, pub) => { - let tx = '{"type":18,"data":{"pub":"'+ - pub+'"}}' - return sign(privKey, sender, tx) + let tx = {type: 18, data: {pub}} + return sign(privKey, sender, JSON.stringify(tx)) }, tippedVote: (privkey, sender, link, author, weight, tag, tip) => { if (!tag) tag = '' - let tx = '{"type":19,"data":{"link":"'+ - link+'", "author":"'+ - author+'", "vt": '+ - parseInt(weight)+', "tag": "'+tag+'", "tip": ' + parseInt(tip) + '}}' - return sign(privkey, sender, tx) + let tx = {type: 19, data: {link, author, vt: parseInt(weight), tag, tip: parseInt(tip)}} + return sign(privkey, sender, JSON.stringify(tx)) }, newWeightedKey: (privKey, sender, id, pub, types, weight) => { - let tx = '{"type":20,"data":{"id":"'+ - id+'","pub":"'+ - pub+'","types":'+types+',"weight":'+weight+'}}' - return sign(privKey, sender, tx) + let tx = {type: 20, data: {id, pub, types: typeof types === 'string' ? JSON.parse(types) : types, weight: parseInt(weight)}} + return sign(privKey, sender, JSON.stringify(tx)) }, setSignatureThreshold: (privKey, sender, thresholds) => { - let tx = '{"type":21,"data":{"thresholds":'+thresholds+'}}' - return sign(privKey, sender, tx) + let tx = {type: 21, data: {thresholds: typeof thresholds === 'string' ? JSON.parse(thresholds) : thresholds}} + return sign(privKey, sender, JSON.stringify(tx)) }, setPasswordWeight: (privKey, sender, weight) => { - let tx = '{"type":22,"data":{"weight":'+weight+'}}' - return sign(privKey, sender, tx) + let tx = {type: 22, data: {weight: parseInt(weight)}} + return sign(privKey, sender, JSON.stringify(tx)) }, unsetSignatureThreshold: (privKey, sender, types) => { - let tx = '{"type":23,"data":{"types":'+types+'}}' - return sign(privKey, sender, tx) + let tx = {type: 23, data: {types: typeof types === 'string' ? JSON.parse(types) : types}} + return sign(privKey, sender, JSON.stringify(tx)) }, createAccountWithBw: (privKey, sender, pub, name, bw) => { - let tx = '{"type":24,"data":{"pub":"'+pub+'","name":"'+name+'","bw":'+parseInt(bw)+'}}' - return sign(privKey, sender, tx) + let tx = {type: 24, data: {pub, name, bw: parseInt(bw)}} + return sign(privKey, sender, JSON.stringify(tx)) }, playlistJson: (privKey, sender, link, json) => { - let tx = '{"type":25,"data":{"link":"'+link+'","json":'+json+'}}' - return sign(privKey, sender, tx) + let tx = {type: 25, data: {link, json: typeof json === 'string' ? JSON.parse(json) : json}} + return sign(privKey, sender, JSON.stringify(tx)) }, playlistPush: (privKey, sender, link, seq) => { - let tx = '{"type":26,"data":{"link":"'+link+'","seq":'+seq+'}}' - return sign(privKey, sender, tx) + let tx = {type: 26, data: {link, seq}} + return sign(privKey, sender, JSON.stringify(tx)) }, playlistPop: (privKey, sender, link, seq) => { - let tx = '{"type":27,"data":{"link":"'+link+'","seq":'+seq+'}}' - return sign(privKey, sender, tx) + let tx = {type: 27, data: {link, seq}} + return sign(privKey, sender, JSON.stringify(tx)) }, commentEdit: (privKey, sender, link, json) => { - let tx = '{"type":28,"data":{"link":"'+link+'","json":'+json+'}}' - return sign(privKey, sender, tx) + let tx = {type: 28, data: {link, json: typeof json === 'string' ? JSON.parse(json) : json}} + return sign(privKey, sender, JSON.stringify(tx)) }, accountAuthorize: (privKey, sender, user, id, types, weight) => { - let tx = '{"type":29,"data":{"user":"'+user+'","id":"'+id+'","types":'+types+',"weight":'+weight+'}}' - return sign(privKey, sender, tx) + let tx = {type: 29, data: {user, id, types: typeof types === 'string' ? JSON.parse(types) : types, weight}} + return sign(privKey, sender, JSON.stringify(tx)) }, accountRevoke: (privKey, sender, user, id) => { - let tx = '{"type":30,"data":{"user":"'+user+'","id":"'+id+'"}}' - return sign(privKey, sender, tx) + let tx = {type: 30, data: {user, id}} + return sign(privKey, sender, JSON.stringify(tx)) }, fundRequestCreate: (privKey, sender, title, description, url, requested, receiver) => { - let tx = '{"type":31,"data":{"title":"'+title+'","description":"'+description+'","url":"'+url+'","requested":'+requested+',"receiver":"'+receiver+'"}}' - return sign(privKey, sender, tx) + let tx = {type: 31, data: {title, description, url, requested: parseInt(requested), receiver}} + return sign(privKey, sender, JSON.stringify(tx)) }, fundRequestContrib: (privKey, sender, id, amount) => { - let tx = '{"type":32,"data":{"id":'+id+',"amount":'+amount+'}}' - return sign(privKey, sender, tx) + let tx = {type: 32, data: {id: parseInt(id), amount: parseInt(amount)}} + return sign(privKey, sender, JSON.stringify(tx)) }, fundRequestWork: (privKey, sender, id, work) => { - let tx = '{"type":33,"data":{"id":'+id+',"work":'+work+'}}' - return sign(privKey, sender, tx) + let tx = {type: 33, data: {id, work: typeof work === 'string' ? JSON.parse(work) : work}} + return sign(privKey, sender, JSON.stringify(tx)) }, fundRequestWorkReview: (privKey, sender, id, approve, memo) => { - let tx = '{"type":34,"data":{"id":'+id+',"approve":'+approve+',"memo":"'+memo+'}}' - return sign(privKey, sender, tx) + let tx = {type: 34, data: {id: parseInt(id), approve: approve === 'true' || approve === '1' ? true : approve === 'false' || approve === '0' ? false : approve, memo}} + return sign(privKey, sender, JSON.stringify(tx)) }, proposalVote: (privKey, sender, id, amount) => { - let tx = '{"type":35,"data":{"id":'+id+',"amount":'+amount+'}}' - return sign(privKey, sender, tx) + let tx = {type: 35, data: {id: parseInt(id), amount: parseInt(amount)}} + return sign(privKey, sender, JSON.stringify(tx)) }, proposalEdit: (privKey, sender, id, title, description, url) => { - let tx = '{"type":36,"data":{"id":'+id+',"title":"'+title+'","description":"'+description+'","url":"'+url+'"}}' - return sign(privKey, sender, tx) + let tx = {type: 36, data: {id, title, description, url}} + return sign(privKey, sender, JSON.stringify(tx)) }, chainUpdateCreate: (privKey, sender, title, description, url, changes) => { - let tx = '{"type":37,"data":{"title":"'+title+'","description":"'+description+'","url":"'+url+'","changes":'+changes+'}}' - return sign(privKey, sender, tx) + let tx = {type: 37, data: {title, description, url, changes: typeof changes === 'string' ? JSON.parse(changes) : changes}} + return sign(privKey, sender, JSON.stringify(tx)) }, mdQueue: (privKey, sender, txtype, payload) => { - let tx = '{"type":38,"data":{"txtype":'+txtype+',"payload":'+payload+'}}' - return sign(privKey, sender, tx) + let tx = {type: 38, data: {txtype: parseInt(txtype), payload: typeof payload === 'string' ? JSON.parse(payload) : payload}} + return sign(privKey, sender, JSON.stringify(tx)) }, mdSign: (privKey, sender, id) => { - let tx = '{"type":39,"data":{"id":'+id+'}}' - return sign(privKey, sender, tx) + let tx = {type: 39, data: {id}} + return sign(privKey, sender, JSON.stringify(tx)) } } diff --git a/src/config.js b/src/config.js index 8d893bd..f5f14a0 100644 --- a/src/config.js +++ b/src/config.js @@ -17,8 +17,11 @@ let config = { b58Alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz', // the block #0 genesis timestamp block0ts: 1601477849000, - // the block hash serialization revision - blockHashSerialization: 1, + // the block hash serialization revision (overridden below) + // the consensus message serialization version + // 1: insertion order (no sort) — legacy + // 2: sorted keys — prevents key-ordering mismatches + consensusSigVersion: 1, // the block time in ms blockTime: 3000, // the number of ms needed for 0.01 DTC to generate 1 byte of bw @@ -51,7 +54,7 @@ let config = { // the maximum number of follows a single account can do followsMax: 2000, // F - hotfix1: false, + // overridden below // the max size of a stringified json input (content / user profile) // best if kept slightly lower than bwMax jsonMaxBytes: 60000, @@ -85,8 +88,7 @@ let config = { masterNoPreloadAcc: true, // the maximum time drift in ms before a block is invalid maxDrift: 200, - // the maximum number of transactions in a single block - maxTxPerBlock: 20, + // the maximum number of transactions in a single block (overridden below) // the max length of a transfer memo memoMaxLength: 250, // defines how long it takes for a notification to get deleted, and how often the purge happens @@ -174,35 +176,64 @@ let config = { preloadVt: 50, // 50% of vtPerBurn preloadBwGrowth: 2, // x2 more time of bwGrowth multisig: true, + // force finalize disabled in base config — enabled at hard fork height below + forceFinalize: false, + // force finalize fallback: if backoff is exhausted without quorum among + // active leaders, fallback to force finalizing anyway. + // WARNING: enabling fallback can create a permanent fork during network + // partitions. When false, the chain halts until quorum is reached — safer. + forceFinalizeFallback: false, }, + // 241600: only txLimits change — matches existing new_net deploy 241600: { txLimits: { 28: 0 } + }, + // Hard fork at 13,325,000, deliberately just above the resume head + // 13,320,067 (~4,933 blocks ≈ 4 h at 3 s). The chain has been halted + // since 2026-06-27, so the cutover is already a coordinated restart: + // the anti-fork safety net does not need to wait for the original + // ~21-day horizon. Must stay STRICTLY above the last produced block: + // lowering the key below it would change config.read(n) for blocks that + // were already produced. + // - forceFinalize: enables anti-fork safety net if consensus stalls + // - consensusSigVersion: 2 (sorted keys) prevents key-ordering mismatches + 13325000: { + forceFinalize: true, + consensusSigVersion: 2 } }, read: (blockNum) => { let finalConfig = {} let latestHf = 0 - for (const key in config.history) + const historyKeys = Object.keys(config.history).map(Number) + for (let hi = 0; hi < historyKeys.length; hi++) { + const key = historyKeys[hi] if (blockNum >= key) { - if (blockNum === parseInt(key) && blockNum !== 0) + if (blockNum === key && blockNum !== 0) logr.info('Hard Fork #'+key) Object.assign(finalConfig, config.history[key]) - latestHf = parseInt(key) - } - else { + latestHf = key + } else { if (config.history[key].ecoBlocks > finalConfig.ecoBlocks && config.history[key].ecoBlocks - finalConfig.ecoBlocks >= key-blockNum) finalConfig.ecoBlocksIncreasesSoon = config.history[key].ecoBlocks break } + } if (typeof cache !== 'undefined' && cache.state && cache.state[1]) { let govConfig = cache.state[1] - for (let k in govConfig) - if (k !== '_id' && govConfig[k].effectiveBlock >= latestHf) - finalConfig[k] = govConfig[k].value + let allowedKeys = Object.values(config.history).flatMap(h => Object.keys(h)) + allowedKeys.push('_id') + Object.keys(govConfig).forEach(k => { + const override = govConfig[k] + if (override && typeof override === 'object' && typeof override.effectiveBlock === 'number' && Object.prototype.hasOwnProperty.call(override, 'value') + && override.effectiveBlock >= latestHf + && allowedKeys.indexOf(k) !== -1) + finalConfig[k] = override.value + }) } return finalConfig diff --git a/src/consensus.js b/src/consensus.js index a76032c..c456b95 100644 --- a/src/consensus.js +++ b/src/consensus.js @@ -1,5 +1,5 @@ const secp256k1 = require('secp256k1') -const CryptoJS = require('crypto-js') +const crypto = require('crypto') const bs58 = require('base-x')(config.b58Alphabet) const cloneDeep = require('clone-deep') const consensus_need = 2 @@ -8,12 +8,18 @@ const consensus_threshold = consensus_need/consensus_total // all p2p.sockets referenced here are verified nodes with a node_status +const FF_BACKOFF_MS = [600, 1200, 2400, 4800] + let consensus = { observer: false, validating: [], processed: [], queue: [], + maxQueueSize: 5000, finalizing: false, + forceFinalizeTimeout: null, + ffProposals: null, + ffResolveTimeout: null, possBlocks: [], getActiveLeaderKey: (name) => { let shuffle = chain.schedule.shuffle @@ -44,6 +50,8 @@ let consensus = { // and out of consensus 2*config.leaders blocks after his last scheduled block let blockNum = chain.getLatestBlock()._id+1 let actives = [] + if (!chain.schedule.shuffle || chain.schedule.shuffle.length === 0) + return actives let currentLeader = chain.schedule.shuffle[(blockNum-1)%config.leaders].name if (consensus.getActiveLeaderKey(currentLeader)) actives.push(currentLeader) @@ -57,75 +65,106 @@ let consensus = { // logr.cons('Leaders: ' + actives.join(',')) return actives }, + tryNextStepBusy: false, tryNextStep: () => { - let consensus_size = consensus.activeLeaders().length - let threshold = consensus_size * consensus_threshold - - // if we are observing, we need +1 to pass consensus as we want to manage our own rounds - if (!consensus.isActive()) - threshold += 1 - - // identify block collisions between blocks of same _id produced by: - // 1. only one leader (double production) - // 2. more than one leader (latency issues between leaders) - // resolution: apply the earliest valid block, or in case of same timestamp the lowest hash - // todo: add leader slashing for double production and other possible malicious behaviour - let possBlocksById = {} - if (consensus.possBlocks.length > 1) { - for (let i in consensus.possBlocks) { - if (possBlocksById[consensus.possBlocks[i].block._id]) - possBlocksById[consensus.possBlocks[i].block._id].push(consensus.possBlocks[i]) - else - possBlocksById[consensus.possBlocks[i].block._id] = [consensus.possBlocks[i]] - } - consensus.possBlocks.sort((a,b) => { - // valid blocks with different _id must have a different timestamp - if (a.block.timestamp !== b.block.timestamp) - return a.block.timestamp - b.block.timestamp - else - return a.block.hash < b.block.hash ? -1 : 1 - }) + if (consensus.finalizing || consensus.tryNextStepBusy) { + setTimeout(() => consensus.tryNextStep(), 100) + return } + consensus.tryNextStepBusy = true + try { + let consensus_size = consensus.activeLeaders().length + // smallest integer STRICTLY above 2/3 (floor+1): `ceil` + `>=` would drop + // the quorum to exactly 2/3 when consensus_size is a multiple of 3 + let threshold = Math.floor(consensus_size * consensus_threshold) + 1 + + // Require at least 3 respondents so no 50% partition can reach consensus alone + if (threshold < 3) threshold = 3 - for (let i = 0; i < consensus.possBlocks.length; i++) { - const possBlock = consensus.possBlocks[i] - logr.cons('T'+Math.ceil(threshold)+' R0-'+possBlock[0].length+' R1-'+possBlock[1].length) - // if 2/3+ of the final round and not already finalizing another block - if (possBlock[config.consensusRounds-1].length > threshold + // if we are observing, we need +1 to pass consensus as we want to manage our own rounds + if (!consensus.isActive()) + threshold += 1 + + // identify block collisions between blocks of same _id produced by: + // 1. only one leader (double production) + // 2. more than one leader (latency issues between leaders) + // resolution: apply the earliest valid block, or in case of same timestamp the lowest hash + // todo: add leader slashing for double production and other possible malicious behaviour + let possBlocksById = {} + if (consensus.possBlocks.length > 1) { + for (let i = 0; i < consensus.possBlocks.length; i++) + if (possBlocksById[consensus.possBlocks[i].block._id]) + possBlocksById[consensus.possBlocks[i].block._id].push(consensus.possBlocks[i]) + else + possBlocksById[consensus.possBlocks[i].block._id] = [consensus.possBlocks[i]] + + consensus.possBlocks.sort((a,b) => { + // valid blocks with different _id must have a different timestamp + if (a.block.timestamp !== b.block.timestamp) + return a.block.timestamp - b.block.timestamp + else + return a.block.hash < b.block.hash ? -1 : 1 + }) + } + + for (let i = 0; i < consensus.possBlocks.length; i++) { + const possBlock = consensus.possBlocks[i] + logr.cons('T'+Math.ceil(threshold)+' R0-'+(possBlock[0]?possBlock[0].length:'?')+' R1-'+(possBlock[1]?possBlock[1].length:'?')) + // if 2/3+ of the final round and not already finalizing another block + if (possBlock[config.consensusRounds-1].length >= threshold && !consensus.finalizing && possBlock.block._id === chain.getLatestBlock()._id+1 && possBlock[0] && possBlock[0].indexOf(process.env.NODE_OWNER) !== -1) { // block becomes valid, we can move forward ! - consensus.finalizing = true - - // log which block got applied if collision exists - if (possBlocksById[possBlock.block._id] && possBlocksById[possBlock.block._id].length > 1) { - let collisions = [] - for (let j in possBlocksById[possBlock.block._id]) - collisions.push([possBlocksById[possBlock.block._id][j].block.miner,possBlocksById[possBlock.block._id][j].block.timestamp]) - logr.info('Block collision detected at height '+possBlock.block._id+', the leaders are:',collisions) - logr.cons('Poss blocks',possBlocksById[possBlock.block._id]) - logr.info('Applying block '+possBlock.block._id+'#'+possBlock.block.hash.substr(0,4)+' by '+possBlock.block.miner+' with timestamp '+possBlock.block.timestamp) - } else - logr.cons('block '+possBlock.block._id+'#'+possBlock.block.hash.substr(0,4)+' got finalized') - - chain.validateAndAddBlock(possBlock.block, false, function(err) { - if (err) throw err - - // clean up old possible blocks - let newPossBlocks = [] - for (let y = 0; y < consensus.possBlocks.length; y++) - if (possBlock.block._id < consensus.possBlocks[y].block._id) - newPossBlocks.push(consensus.possBlocks[y]) + consensus.finalizing = true + + // log which block got applied if collision exists + if (possBlocksById[possBlock.block._id] && possBlocksById[possBlock.block._id].length > 1) { + let collisions = [] + let collisionBlocks = possBlocksById[possBlock.block._id] + for (let j = 0; j < collisionBlocks.length; j++) + collisions.push([collisionBlocks[j].block.miner, collisionBlocks[j].block.timestamp]) + logr.info('Block collision detected at height '+possBlock.block._id+', the leaders are:',collisions) + logr.cons('Poss blocks',possBlocksById[possBlock.block._id]) + logr.info('Applying block '+possBlock.block._id+'#'+possBlock.block.hash.substr(0,4)+' by '+possBlock.block.miner+' with timestamp '+possBlock.block.timestamp) + } else + logr.cons('block '+possBlock.block._id+'#'+possBlock.block.hash.substr(0,4)+' got finalized') + + chain.validateAndAddBlock(possBlock.block, false, function(err) { + try { + if (err) { + logr.error('Consensus block validation failed for '+possBlock.block._id+'#'+possBlock.block.hash.substr(0,8)+' by '+possBlock.block.miner, err) + cache.rollback() + dao.resetID() + daoMaster.resetID() + consensus.possBlocks = consensus.possBlocks.filter(pb => pb.block.hash !== possBlock.block.hash) + consensus.finalizing = false + return + } + + // clean up old possible blocks + let newPossBlocks = [] + for (let y = 0; y < consensus.possBlocks.length; y++) + if (possBlock.block._id < consensus.possBlocks[y].block._id) + newPossBlocks.push(consensus.possBlocks[y]) - consensus.possBlocks = newPossBlocks - consensus.finalizing = false - }) + consensus.possBlocks = newPossBlocks + consensus.finalizing = false + if (config.forceFinalize) + consensus.cancelForceFinalize() + } catch (e) { + logr.error('Unhandled error in validateAndAddBlock callback', e) + consensus.finalizing = false + } + }) + } + // if 2/3+ of any previous round, we try to commit it again + else for (let y = 0; y < config.consensusRounds-1; y++) + if (possBlock[y].length >= threshold) + consensus.round(y+1, possBlock.block) } - // if 2/3+ of any previous round, we try to commit it again - else for (let y = 0; y < config.consensusRounds-1; y++) - if (possBlock[y].length > threshold) - consensus.round(y+1, possBlock.block) + } finally { + consensus.tryNextStepBusy = false } }, round: (round, block, cb) => { @@ -176,14 +215,20 @@ let consensus = { chain.isValidNewBlock(block, true, true, function(isValid) { consensus.validating.splice(consensus.validating.indexOf(possBlock.block.hash), 1) if (!isValid) { - // todo add punishment (close socket?) + if (block.hash && p2p && p2p.recordBlockFailure) + p2p.recordBlockFailure(block.hash) logr.error('Received invalid new block from '+block.miner, block.hash) if (cb) cb(-1) } else { logr.cons('Precommitting block '+block._id+'#'+block.hash.substr(0,4)) // adding to possible blocks - consensus.possBlocks.push(possBlock) + if (consensus.possBlocks.length >= consensus.activeLeaders().length * 2) + logr.warn('possBlocks at capacity, not adding new block') + else + consensus.possBlocks.push(possBlock) + if (config.forceFinalize) + consensus.scheduleForceFinalize() // adding ourselves to precommit list for (let i = 0; i < consensus.possBlocks.length; i++) if (block.hash === consensus.possBlocks[i].block.hash @@ -192,14 +237,20 @@ let consensus = { // processing queued messages for this block for (let i = 0; i < consensus.queue.length; i++) { - if (consensus.queue[i].d.b.hash === possBlock.block.hash) { - // logr.warn('From Queue: '+consensus.queue[i].d.b.hash) - consensus.remoteRoundConfirm(consensus.queue[i]) + const msg = consensus.queue[i] + if (!msg || !msg.d || !msg.d.b || !msg.d.b.hash) { + consensus.queue.splice(i, 1) + i-- + continue + } + if (msg.d.b.hash === possBlock.block.hash) { + // logr.warn('From Queue: '+msg.d.b.hash) + consensus.remoteRoundConfirm(msg) consensus.queue.splice(i, 1) i-- continue } - if (consensus.queue[i].d.ts + 2*config.blockTime < new Date().getTime()) { + if (msg.d.ts + 2*config.blockTime < new Date().getTime()) { consensus.queue.splice(i, 1) i-- } @@ -240,32 +291,356 @@ let consensus = { let block = message.d.b let round = message.d.r let leader = message.s.n + + // Validate round as integer within configured consensus range + if (typeof round !== 'number' || round !== Math.floor(round) || round < 0 || round >= config.consensusRounds) + return for (let i = 0; i < consensus.possBlocks.length; i++) if (block.hash === consensus.possBlocks[i].block.hash) { - if (consensus.possBlocks[i][round] && consensus.possBlocks[i][round].indexOf(leader) === -1) { - // this leader has not already confirmed this round - // add the leader to the ones who passed precommit - - for (let r = round; r >= 0; r--) - if (consensus.possBlocks[i][r].indexOf(leader) === -1) - consensus.possBlocks[i][r].push(leader) - - consensus.tryNextStep() - } + if (!consensus.possBlocks[i][round] || consensus.possBlocks[i][round].indexOf(leader) !== -1) + break + + // Add the leader only to the round they actually confirmed + if (consensus.possBlocks[i][round]) + consensus.possBlocks[i][round].push(leader) + + consensus.tryNextStep() break } }, signMessage: (message) => { - let hash = CryptoJS.SHA256(JSON.stringify(message)).toString() + let sigVersion = config.consensusSigVersion || 1 + let serialized + if (sigVersion === 2) + serialized = JSON.stringify(Object.keys(message).sort().reduce((o, k) => { o[k] = message[k]; return o }, {})) + else + serialized = JSON.stringify(message) + let hash = crypto.createHash('sha256').update(serialized).digest('hex') let signature = secp256k1.ecdsaSign(Buffer.from(hash, 'hex'), bs58.decode(process.env.NODE_OWNER_PRIV)) signature = bs58.encode(signature.signature) message.s = { n: process.env.NODE_OWNER, - s: signature + s: signature, + v: sigVersion } return message }, + handleForceFinalizeProposal: (message) => { + if (!consensus.ffProposals) return + const sender = message.s && message.s.n + if (!sender || !consensus.getActiveLeaderKey(sender)) return + const actives = consensus.activeLeaders() + if (actives.indexOf(sender) === -1) return + if (message.d.height !== consensus.ffProposals.height) return + + // Determine which hash this sender is voting for + let hash = message.d.hash + if (!hash && Array.isArray(message.d.hashes)) { + // Pick best local match from the sender's candidate list + const local = consensus.possBlocks.filter(pb => + pb.block._id === message.d.height + && message.d.hashes.indexOf(pb.block.hash) !== -1 + ) + local.sort((a, b) => { + if (a.block.timestamp !== b.block.timestamp) + return a.block.timestamp - b.block.timestamp + return a.block.hash < b.block.hash ? -1 : 1 + }) + hash = local[0] && local[0].block.hash + } + if (!hash) return + + // Only accept votes for blocks we actually have locally + if (!consensus.ffProposals.proposals[hash]) + for (let i = 0; i < consensus.possBlocks.length; i++) { + const pb = consensus.possBlocks[i] + if (pb.block.hash === hash && pb.block._id === message.d.height) { + consensus.ffProposals.proposals[hash] = pb + break + } + } + + if (!consensus.ffProposals.proposals[hash]) return + + // Track this respondent + if (consensus.ffProposals.respondents[sender] !== hash) { + consensus.ffProposals.respondents[sender] = hash + logr.cons('FF respondent: ' + sender + ' for ' + message.d.height + '#' + hash.substr(0, 8)) + } + + // Re-broadcast the proposal to accelerate convergence + if (p2p && p2p.broadcastNotSent) + p2p.broadcastNotSent(message) + }, + cancelForceFinalize: (safe) => { + // don't null ffProposals if a resolve is in-flight — let it complete + if (safe && consensus.finalizing) return + clearTimeout(consensus.forceFinalizeTimeout) + consensus.forceFinalizeTimeout = null + if (consensus.ffResolveTimeout) { + clearTimeout(consensus.ffResolveTimeout) + consensus.ffResolveTimeout = null + } + if (!safe) consensus.ffProposals = null + }, + scheduleForceFinalize: () => { + const latestBlock = chain.getLatestBlock() + const expectedHeight = latestBlock._id + 1 + // skip if timer already set for this height (don't reset = don't delay) + if (consensus.forceFinalizeTimeout || consensus.finalizing) return + const hasCandidate = consensus.possBlocks.some(pb => pb.block._id === expectedHeight) + if (!hasCandidate) return + + const fromNow = Math.max(1000, + latestBlock.timestamp + config.blockTime * (config.leaders + config.consensusRounds + 2) - Date.now() + ) + + if (fromNow > 86400000) { + logr.warn('Force finalize scheduled too far in the future (' + fromNow + 'ms) for height ' + expectedHeight + ', skipping') + return + } + + logr.debug('Force finalize scheduled in ' + fromNow + 'ms for height ' + expectedHeight) + + consensus.forceFinalizeTimeout = setTimeout(() => { + consensus._forceFinalize(expectedHeight) + }, fromNow) + + if (consensus.forceFinalizeTimeout.unref) + consensus.forceFinalizeTimeout.unref() + }, + _getQuorumThreshold: () => { + const activeCount = Math.max(1, consensus.activeLeaders().length) + const configThreshold = Math.ceil(config.leaders * 2 / 3) + const activeThreshold = Math.ceil(activeCount * 2 / 3) + // Require at least 3 respondents so no 50% partition can force-finalize + return Math.min(configThreshold, Math.max(activeThreshold, 3)) + }, + _forceFinalize: (height, candidateRetry) => { + consensus.forceFinalizeTimeout = null + if (consensus.finalizing) return + if (!config.forceFinalize) return + if (height !== chain.getLatestBlock()._id + 1) return + + if (candidateRetry === undefined) candidateRetry = 0 + if (candidateRetry >= 3) { + logr.fatal('Force finalize: retry limit exceeded for height ' + height) + consensus.finalizing = false + return + } + + let candidates = consensus.possBlocks.filter(pb => pb.block._id === height) + if (candidates.length === 0) { + logr.warn('Force finalize has no candidates for height ' + height) + consensus.finalizing = false + return + } + + candidates.sort((a, b) => { + if (a.block.timestamp !== b.block.timestamp) + return a.block.timestamp - b.block.timestamp + return a.block.hash.localeCompare(b.block.hash) + }) + + const winner = candidates[0] + + if (candidates.length > 1) { + let details = candidates.map(c => [ + c.block.miner, + c.block._id + '#' + (c.block.hash || '??').substr(0, 8), + c.block.timestamp, + (c.block.hash || '??').substr(0, 8) + ]) + logr.info('Block collision timeout at height ' + height + ', forced selection:', details) + } + + if (candidates.length > 1) { + const winnerHash = (winner.block.hash || '??').substr(0, 8) + logr.warn('Force finalizing block ' + height + '#' + winnerHash + ' by ' + winner.block.miner + ' — selected locally without consensus, fork risk if peers diverge') + } + + // Lock finalizing before ffProposals/broadcast so tryNextStep can't race + // and finalize a different block while we're in the anti-fork protocol. + consensus.finalizing = true + + // Anti-fork: broadcast ALL candidates to peers and collect responses before committing + // Dedup: skip if we already have an in-flight proposal at the same height + if (consensus.ffProposals && consensus.ffProposals.height === height) { + consensus.finalizing = false + return + } + const ownName = process.env.NODE_OWNER + const candidateHashes = candidates.map(c => c.block.hash) + consensus.ffProposals = { height, proposals: {}, respondents: {} } + candidates.forEach(c => { consensus.ffProposals.proposals[c.block.hash] = c }) + if (consensus.getActiveLeaderKey(ownName)) + consensus.ffProposals.respondents[ownName] = winner.block.hash + + if (p2p && p2p.broadcast) { + const proposal = consensus.signMessage({ + t: 7, + d: { height, hashes: candidateHashes, timestamp: winner.block.timestamp } + }) + p2p.broadcast(proposal) + } + consensus._resolveForceFinalize(height, candidateRetry, 0) + }, + _resolveForceFinalize: (height, candidateRetry, ffAttempt) => { + consensus.ffResolveTimeout = null + if (!consensus.ffProposals) { + logr.warn('FF resolve: ffProposals cleared without finalization at height ' + height + ', rescheduling') + consensus.finalizing = false + const retryTimer = setTimeout(() => consensus.scheduleForceFinalize(), 5000) + if (retryTimer.unref) retryTimer.unref() + return + } + + const allCandidates = Object.values(consensus.ffProposals.proposals) + if (allCandidates.length === 0) { + logr.error('FF resolve: no proposals for height ' + height) + consensus.ffProposals = null + consensus.finalizing = false + return + } + allCandidates.sort((a, b) => { + if (a.block.timestamp !== b.block.timestamp) + return a.block.timestamp - b.block.timestamp + return a.block.hash.localeCompare(b.block.hash) + }) + + const activeLeadersCount = consensus.activeLeaders().length + const quorumThreshold = consensus._getQuorumThreshold() + const respondents = consensus.ffProposals.respondents + const respondentCount = Object.keys(respondents).length + + // Count votes per hash among respondents + const hashVotes = {} + for (const hash of Object.values(respondents)) + hashVotes[hash] = (hashVotes[hash] || 0) + 1 + + + const bestHash = Object.keys(hashVotes).length > 0 + ? Object.keys(hashVotes).reduce((a, b) => hashVotes[a] > hashVotes[b] ? a : b) + : allCandidates[0].block.hash + const bestVotes = bestHash ? (hashVotes[bestHash] || 0) : 0 + const hasQuorum = bestVotes >= quorumThreshold + + const respondentsByHash = {} + for (const [name, hash] of Object.entries(respondents)) + (respondentsByHash[hash] = respondentsByHash[hash] || []).push(name) + + if (hasQuorum) + logr.cons('FF quorum reached: ' + bestVotes + '/' + quorumThreshold + ' for ' + height + '#' + bestHash.substr(0, 8)) + else { + const totalLeaders = activeLeadersCount || respondents.length + logr.cons('FF quorum not met: ' + bestVotes + '/' + quorumThreshold + ' (' + respondentCount + '/' + totalLeaders + ' respondents)') + } + + // Find the block for bestHash + const bestBlock = allCandidates.find(c => c.block.hash === bestHash) + if (!bestBlock) + logr.error('FF resolve: best hash ' + bestHash.substr(0, 8) + ' not found among candidates, using local winner') + + + if (hasQuorum) { + if (bestBlock && bestBlock.block.hash !== allCandidates[0].block.hash) + logr.info('Anti-fork: quorum selected ' + height + '#' + bestBlock.block.hash.substr(0, 8) + ' by ' + bestBlock.block.miner + ' (local was ' + allCandidates[0].block.miner + ')') + + consensus.ffProposals = null + consensus._applyForceFinalize(height, bestBlock || allCandidates[0], candidateRetry) + return + } + + const maxAttempts = FF_BACKOFF_MS.length + if (ffAttempt + 1 < maxAttempts) { + const delay = FF_BACKOFF_MS[ffAttempt + 1] + logr.cons('FF retry ' + (ffAttempt + 1) + '/' + maxAttempts + ' in ' + delay + 'ms for height ' + height) + + // Reset respondents for fresh round — preserve existing votes to prevent vote replay + const prevRespondents = {} + if (consensus.ffProposals && consensus.ffProposals.respondents) + Object.assign(prevRespondents, consensus.ffProposals.respondents) + consensus.ffProposals.respondents = prevRespondents + + // Re-broadcast proposal in case peers missed it + if (p2p && p2p.broadcast) { + const winner = allCandidates[0] + const proposal = consensus.signMessage({ + t: 7, + d: { height, hashes: allCandidates.map(c => c.block.hash), timestamp: winner.block.timestamp } + }) + p2p.broadcast(proposal) + } + + consensus.ffResolveTimeout = setTimeout(() => { + consensus._resolveForceFinalize(height, candidateRetry, ffAttempt + 1) + }, delay) + if (consensus.ffResolveTimeout && consensus.ffResolveTimeout.unref) + consensus.ffResolveTimeout.unref() + } else { + if (!config.forceFinalizeFallback) { + logr.fatal('FF backoff exhausted and fallback disabled — chain halts at height ' + height + '. Quorum: ' + bestVotes + '/' + quorumThreshold + '. Retrying in 10s...') + consensus.ffProposals = null + consensus.finalizing = false + const retryTimer = setTimeout(() => consensus.scheduleForceFinalize(), 10000) + if (retryTimer.unref) retryTimer.unref() + return + } + const collisionRisk = Object.keys(hashVotes).length > 1 + if (collisionRisk) + logr.fatal('FF backoff exhausted with ' + Object.keys(hashVotes).length + ' conflicting hashes for height ' + height + '. FORK RISK. Respondents:', respondentsByHash) + else + logr.warn('FF backoff exhausted without quorum for height ' + height + ' (' + respondentCount + '/' + quorumThreshold + ' respondents). Proceeding with best candidate.') + + consensus.ffProposals = null + consensus._applyForceFinalize(height, bestBlock || allCandidates[0], candidateRetry) + } + }, + _applyForceFinalize: (height, winner, retryCount) => { + if (!winner || !winner.block) { + logr.error('Force finalize has no valid winner for height ' + height + ', skipping') + consensus.finalizing = false + return + } + chain.validateAndAddBlock(winner.block, true, function(err) { + if (err) { + const blockHash = (winner && winner.block && winner.block.hash) || 'unknown' + logr.error('Force finalize failed for ' + height + '#' + blockHash.substr(0, 8), err) + consensus.possBlocks = consensus.possBlocks.filter(pb => pb.block.hash !== blockHash) + const remaining = consensus.possBlocks.filter(pb => pb.block._id === height) + if (remaining.length > 0 && retryCount < 3) { + logr.warn('Trying next candidate for height ' + height + ' (retry ' + (retryCount + 1) + '/3)') + setImmediate(() => { + consensus.finalizing = false + consensus._forceFinalize(height, retryCount + 1) + }) + return + } + if (remaining.length > 0) + logr.fatal('Force finalize: retry limit exceeded for height ' + height + '. All candidates failed. Manual intervention required.') + else + logr.fatal('Force finalize: no remaining candidates for height ' + height + ' after eviction. Chain stalled.') + + consensus.finalizing = false + return + } + + // cleanup P2P blockSenders — delete entries for all finalized blocks + if (p2p && p2p.blockSenders && winner.block && winner.block.phash) + Object.keys(p2p.blockSenders).forEach(h => { + if (h === winner.block.hash || h === winner.block.phash) + delete p2p.blockSenders[h] + }) + let newPossBlocks = [] + for (let y = 0; y < consensus.possBlocks.length; y++) + if (height < consensus.possBlocks[y].block._id) + newPossBlocks.push(consensus.possBlocks[y]) + consensus.possBlocks = newPossBlocks + consensus.finalizing = false + consensus.cancelForceFinalize() + }) + }, verifySignature: (message, cb) => { if (!message || !message.s) { cb(false) @@ -273,9 +648,15 @@ let consensus = { } let sign = message.s.s let name = message.s.n + let sigVersion = message.s.v || 1 let tmpMess = cloneDeep(message) delete tmpMess.s - let hash = CryptoJS.SHA256(JSON.stringify(tmpMess)).toString() + let serialized + if (sigVersion === 2) + serialized = JSON.stringify(Object.keys(tmpMess).sort().reduce((o, k) => { o[k] = tmpMess[k]; return o }, {})) + else + serialized = JSON.stringify(tmpMess) + let hash = crypto.createHash('sha256').update(serialized).digest('hex') let pub = consensus.getActiveLeaderKey(name) if (pub && secp256k1.ecdsaVerify( bs58.decode(sign), @@ -284,6 +665,21 @@ let consensus = { cb(true) return } + // Transition fallback: before the hardfork, accept the other serialization too + if (!config.forceFinalize) { + if (sigVersion === 2) + serialized = JSON.stringify(tmpMess) + else + serialized = JSON.stringify(Object.keys(tmpMess).sort().reduce((o, k) => { o[k] = tmpMess[k]; return o }, {})) + hash = crypto.createHash('sha256').update(serialized).digest('hex') + if (pub && secp256k1.ecdsaVerify( + bs58.decode(sign), + Buffer.from(hash, 'hex'), + bs58.decode(pub))) { + cb(true) + return + } + } cb(false) }, } diff --git a/src/dao.js b/src/dao.js index 0f337e9..26e08cf 100644 --- a/src/dao.js +++ b/src/dao.js @@ -48,8 +48,8 @@ let dao = { return dao.fundRequestStatus.revisionRequired else if (proposal.reviewDeadline > ts) return dao.fundRequestStatus.reviewInProgress - else - return dao.fundRequestStatus.proposalComplete + else + return dao.fundRequestStatus.proposalComplete }, getFundRequestReviewThreshold: (proposal) => { let snapshotLength = proposal.leaderSnapshot.length @@ -181,19 +181,19 @@ let dao = { for (let i in activeRequests) { cache.proposals[activeRequests[i]._id] = activeRequests[i] switch (activeRequests[i].status) { - case dao.fundRequestStatus.votingActive: - dao.activeProposalIDs[activeRequests[i]._id] = activeRequests[i].votingEnds - break - case dao.fundRequestStatus.fundingActive: - dao.activeProposalIDs[activeRequests[i]._id] = activeRequests[i].fundingEnds - break - case dao.fundRequestStatus.fundingSuccess: - case dao.fundRequestStatus.revisionRequired: - dao.activeProposalIDs[activeRequests[i]._id] = activeRequests[i].deadline - break - case dao.fundRequestStatus.reviewInProgress: - dao.activeProposalIDs[activeRequests[i]._id] = activeRequests[i].reviewDeadline - break + case dao.fundRequestStatus.votingActive: + dao.activeProposalIDs[activeRequests[i]._id] = activeRequests[i].votingEnds + break + case dao.fundRequestStatus.fundingActive: + dao.activeProposalIDs[activeRequests[i]._id] = activeRequests[i].fundingEnds + break + case dao.fundRequestStatus.fundingSuccess: + case dao.fundRequestStatus.revisionRequired: + dao.activeProposalIDs[activeRequests[i]._id] = activeRequests[i].deadline + break + case dao.fundRequestStatus.reviewInProgress: + dao.activeProposalIDs[activeRequests[i]._id] = activeRequests[i].reviewDeadline + break } } }, @@ -208,12 +208,12 @@ let dao = { for (let i in activeProposals) { cache.proposals[activeProposals[i]._id] = activeProposals[i] switch (activeProposals[i].status) { - case dao.chainUpdateStatus.votingActive: - dao.activeProposalIDs[activeProposals[i]._id] = activeProposals[i].votingEnds - break - case dao.chainUpdateStatus.votingSuccess: - dao.activeProposalIDs[activeProposals[i]._id] = activeProposals[i].executionTs - break + case dao.chainUpdateStatus.votingActive: + dao.activeProposalIDs[activeProposals[i]._id] = activeProposals[i].votingEnds + break + case dao.chainUpdateStatus.votingSuccess: + dao.activeProposalIDs[activeProposals[i]._id] = activeProposals[i].executionTs + break } } }, diff --git a/src/daoMaster.js b/src/daoMaster.js index 6270ad3..43970ed 100644 --- a/src/daoMaster.js +++ b/src/daoMaster.js @@ -14,19 +14,20 @@ let daoMaster = { cache.findOne('accounts',{name: config.masterName},(e,acc) => transactions.validate(op,ts,acc,cb)) }, executeOperation: (operation,ts) => { - return new Promise(async (rs) => { - let adj = await daoMaster.adjustOperation(operation) - // revalidate, error if invalid at time of execution - daoMaster.validateOperation(operation.type,operation.data,ts,(isvalid,em) => { - if (isvalid) - transactions.execute({ - type: operation.type, - data: operation.data, - sender: config.masterName, - ts: ts - },ts,() => cache.updateOne('masterdao',{_id: operation._id},{$set: { executed: ts, adjustments: adj }},() => rs(true))) - else - cache.updateOne('masterdao',{_id: operation._id},{$set: { executed: ts, error: em }},() => rs(true)) + return new Promise((rs) => { + daoMaster.adjustOperation(operation).then(adj => { + // revalidate, error if invalid at time of execution + daoMaster.validateOperation(operation.type,operation.data,ts,(isvalid,em) => { + if (isvalid) + transactions.execute({ + type: operation.type, + data: operation.data, + sender: config.masterName, + ts: ts + },ts,() => cache.updateOne('masterdao',{_id: operation._id},{$set: { executed: ts, adjustments: adj }},() => rs(true))) + else + cache.updateOne('masterdao',{_id: operation._id},{$set: { executed: ts, error: em }},() => rs(true)) + }) }) }) }, diff --git a/src/economics.js b/src/economics.js index ee92876..051dc0f 100644 --- a/src/economics.js +++ b/src/economics.js @@ -65,10 +65,8 @@ let eco = { cleanHistory: () => { if (config.ecoBlocksIncreasesSoon) return let extraBlocks = eco.history.length - config.ecoBlocks - while (extraBlocks > 0) { - eco.history.shift() - extraBlocks-- - } + if (extraBlocks > 0) + eco.history.splice(0, extraBlocks) }, tallyVotes: (txs = []) => { let votes = 0 @@ -86,6 +84,9 @@ let eco = { let distributed = 0 let votes = 0 if (!eco.startRewardPool) { + if (!eco.history || eco.history.length === 0) + return { theo: theoricalPool, burn: 0, dist: 0, votes: 0, avail: theoricalPool } + distributed = eco.history[eco.history.length-1].cDist burned = eco.history[eco.history.length-1].cBurn let firstBlockIndex = eco.history.length - config.ecoBlocks @@ -140,6 +141,7 @@ let eco = { }, curation: (author, link, cb) => { cache.findOne('contents', {_id: author+'/'+link}, function(err, content) { + if (!content || !content.votes || content.votes.length === 0) return cb(0, 0) let currentVote = content.votes[content.votes.length-1] // first loop to calculate the VP of active votes @@ -305,7 +307,7 @@ let eco = { // otherwise we proportionally reduce based on recent votes weight // and how much is available for printing else - thNewCoins = stats.avail * Math.abs((vt) / stats.votes) + thNewCoins = Math.min(stats.avail * Math.abs((vt) / stats.votes), Number.MAX_SAFE_INTEGER) // rounding down thNewCoins = eco.floor(thNewCoins) @@ -320,8 +322,9 @@ let eco = { return thNewCoins }, rentability: (ts1, ts2, isDv) => { + if (typeof ts1 !== 'number' || typeof ts2 !== 'number' || isNaN(ts1) || isNaN(ts2)) return 0 let ts = ts2 - ts1 - if (ts < 0) throw 'Invalid timestamp in rentability calculation' + if (ts < 0) return config.ecoBaseRent || 0 // https://imgur.com/a/GTLvs37 let directionRent = isDv ? config.ecoDvRentFactor : 1 @@ -357,8 +360,14 @@ let eco = { rentability = Math.floor(directionRent*rentability*Math.pow(10, config.ecoRentPrecision))/Math.pow(10, config.ecoRentPrecision) return rentability }, - round: (val = 0) => Math.round(val*Math.pow(10,config.ecoClaimPrecision))/Math.pow(10,config.ecoClaimPrecision), - floor: (val = 0) => Math.floor(val*Math.pow(10,config.ecoClaimPrecision))/Math.pow(10,config.ecoClaimPrecision) + round: (val = 0) => { + if (typeof val !== 'number' || isNaN(val)) val = 0 + return Math.round(val*Math.pow(10,config.ecoClaimPrecision))/Math.pow(10,config.ecoClaimPrecision) + }, + floor: (val = 0) => { + if (typeof val !== 'number' || isNaN(val)) val = 0 + return Math.floor(val*Math.pow(10,config.ecoClaimPrecision))/Math.pow(10,config.ecoClaimPrecision) + } } module.exports = eco \ No newline at end of file diff --git a/src/http/account/index.js b/src/http/account/index.js index 0aa5f5c..85d222d 100644 --- a/src/http/account/index.js +++ b/src/http/account/index.js @@ -25,8 +25,8 @@ module.exports = { * @apiSuccess {String} [pub_leader] Leader signing public key of account */ app.get('/account/:name', (req, res) => { - if (!req.params.name) { - res.sendStatus(500) + if (!validate.string(req.params.name, config.accountMaxLength, config.accountMinLength, config.allowedUsernameChars, config.allowedUsernameCharsOnlyMiddle)) { + res.sendStatus(404) return } db.collection('accounts').findOne({ name: req.params.name }, function (err, account) { diff --git a/src/http/accountByKey/index.js b/src/http/accountByKey/index.js index e3aaebb..476399d 100644 --- a/src/http/accountByKey/index.js +++ b/src/http/accountByKey/index.js @@ -18,7 +18,7 @@ module.exports = { ] parallel(ops,(errors,results) => { if (errors) - return res.status(500).send(errors) + return res.status(500).send({error: 'query failed'}) return res.send(results) }) }) diff --git a/src/http/addPeer/index.js b/src/http/addPeer/index.js index dd62bd5..1005d8e 100644 --- a/src/http/addPeer/index.js +++ b/src/http/addPeer/index.js @@ -1,9 +1,44 @@ +const rateLimit = require('express-rate-limit') +const { isPrivateURL, resolveAndPin, checkRebinding } = require('../ssrf') + +const peerLimiter = rateLimit({ + windowMs: 60000, + max: 5, + message: { error: 'too many peer requests' } +}) + module.exports = { init: (app) => { // connect to a new peer - app.post('/addPeer', (req, res) => { - p2p.connect([req.body.peer]) - res.send() + app.post('/addPeer', peerLimiter, async (req, res) => { + try { + const peer = req.body.peer + if (!peer || typeof peer !== 'string') + return res.status(400).send({error: 'invalid peer'}) + if (!peer.startsWith('ws://') && !peer.startsWith('wss://')) + return res.status(400).send({error: 'invalid peer protocol'}) + + const parsed = new URL(peer) + let host = parsed.hostname + + const pinnedIp = await resolveAndPin(host) + if (!pinnedIp) + return res.status(400).send({error: 'cannot resolve peer hostname'}) + + if (!(await checkRebinding(host, pinnedIp))) + return res.status(400).send({error: 'dns rebinding detected'}) + + if (await isPrivateURL('http://' + pinnedIp)) + return res.status(400).send({error: 'private peer not allowed'}) + + // Rebuild peer URL with the vetted IP to ensure we connect to the resolved address + parsed.hostname = pinnedIp + parsed.port = parsed.port || (parsed.protocol === 'wss:' ? 443 : 80) + p2p.connect([parsed.toString()]) + res.send() + } catch { + return res.status(400).send({error: 'invalid peer url'}) + } }) } } diff --git a/src/http/allminers/index.js b/src/http/allminers/index.js index 7932d5b..0557308 100644 --- a/src/http/allminers/index.js +++ b/src/http/allminers/index.js @@ -8,16 +8,18 @@ module.exports = { * @apiSuccess {Array} accounts List of accounts ranked by `node_appr` regardless of existence of a valid signing key. */ app.get('/allminers', (req, res) => { + const limit = Math.min(Math.max(parseInt(req.query.limit, 10) || 50, 1), 100) db.collection('accounts').find({ node_appr: { $gt: 0 } }, { - sort: { node_appr: -1 } + sort: { node_appr: -1 }, + limit }).toArray(function (err, accounts) { if (err) return res.status(500).send({ error: 'failed to fetch miners' }) db.collection('leaders').find({ voters: { $gt: 0 } },{}).toArray((err,leaders) => { if (err) return res.status(500).send({ error: 'failed to fetch leader stats' }) let leaderObj = {} - for (let i in leaders) + for (let i = 0; i < leaders.length; i++) leaderObj[leaders[i]._id] = leaders[i] - for (let i in accounts) { + for (let i = 0; i < accounts.length; i++) { accounts[i].subbed = (accounts[i].follows ? accounts[i].follows.length : 0) accounts[i].subs = (accounts[i].followers ? accounts[i].followers.length : 0) delete accounts[i].follows diff --git a/src/http/auth/index.js b/src/http/auth/index.js new file mode 100644 index 0000000..3c67fa1 --- /dev/null +++ b/src/http/auth/index.js @@ -0,0 +1,138 @@ +const crypto = require('crypto') +const rateLimit = require('express-rate-limit') + +const sessions = new Map() + +const SESSION_TTL = 24 * 60 * 60 * 1000 + +setInterval(() => { + const now = Date.now() + for (const [sid, data] of sessions) + if (now - data.ts > SESSION_TTL) + sessions.delete(sid) +}, 60000) + +function safeEqual(a, b) { + if (typeof a !== 'string' || typeof b !== 'string') return false + if (a.length !== b.length) return false + try { + return crypto.timingSafeEqual(Buffer.from(a), Buffer.from(b)) + } catch { + return false + } +} + +function clientIp(req) { + // Prefer the socket address. X-Forwarded-For is only trustworthy when the + // node is explicitly configured to sit behind a trusted proxy (which makes + // express populate req.ip correctly); reading the header directly would let + // a direct client forge the session's bound address. + if (req.ip) return req.ip + return (req.socket && req.socket.remoteAddress) || '' +} + +function getSessionId(req) { + const cookie = req.headers['cookie'] || '' + const m = cookie.split(';').map(c => c.trim()).find(c => c.startsWith('auth_session=')) + return m ? m.split('=').slice(1).join('=') : null +} + +function getToken(req) { + const header = req.headers['authorization'] ? req.headers['authorization'].replace('Bearer ', '') : '' + const query = req.query.token || '' + return header || query +} + +function setSessionCookie(res, sid) { + const secure = res.req && (res.req.secure || res.req.headers['x-forwarded-proto'] === 'https') ? '; Secure' : '' + res.set('Set-Cookie', 'auth_session=' + sid + '; Path=/; HttpOnly; SameSite=Strict' + secure) +} + +function adminTokens() { + const vars = ['ADMIN_TOKEN', 'LOG_ADMIN_TOKEN', 'MINE_TOKEN', 'DEBUG_TOKEN', 'RECOVER_TOKEN'] + return vars.map(v => process.env[v]).filter(Boolean) +} + +// Validates a session cookie and refreshes its timestamp. Enforces the +// client-address binding so a stolen cookie is only usable from the address it +// was issued to. Shared by requireAuth() and by endpoints that need a plain +// boolean check (e.g. the logs SSE stream). +function isValidSession(req) { + const sid = getSessionId(req) + if (!sid) return false + const sess = sessions.get(sid) + if (!sess) return false + if (sess.ip && sess.ip !== clientIp(req)) + return false + sess.ts = Date.now() + return true +} + +function requireAuth(...tokenEnvVars) { + return (req, res, next) => { + if (isValidSession(req)) + return next() + + const candidates = tokenEnvVars.length ? tokenEnvVars.map(v => process.env[v]).filter(Boolean) : adminTokens() + + // No token configured anywhere: fail closed. The same HTTP_HOST=0.0.0.0 + // that publishes the public API also publishes these admin endpoints + // (/mineBlock, /debug, /recover, /logs), so an unconfigured node must + // not serve them anonymously. Operators who deliberately want token-less + // access (local curl) opt in explicitly with ADMIN_ALLOW_ANONYMOUS=1. + if (!candidates.length) { + if (process.env.ADMIN_ALLOW_ANONYMOUS === '1') + return next() + return res.status(401).json({ error: 'admin token not configured' }) + } + + const token = getToken(req) + if (token) { + for (const expected of candidates) + if (safeEqual(token, expected)) { + const newSid = crypto.randomBytes(16).toString('hex') + sessions.set(newSid, { ts: Date.now(), ip: clientIp(req) }) + setSessionCookie(res, newSid) + return next() + } + } + + const accept = req.headers['accept'] || '' + if (accept.includes('text/html') || accept.includes('*/*')) + res.status(401).set('Content-Type', 'text/html; charset=utf-8').send(renderPopup()) + else + res.status(401).json({ error: 'authentication required' }) + } +} + +function renderPopup() { + return '\n\n\n\n\nAuthentication Required\n\n\n\n\n\n\n' +} + +module.exports = { + init: (app) => { + const authLimiter = rateLimit({ + windowMs: 60000, + max: 5, + message: { error: 'too many auth attempts' } + }) + app.post('/auth/login', authLimiter, (req, res) => { + const code = req.body && req.body.code + const tokens = adminTokens() + if (!code || !tokens.length) + return res.status(401).json({ error: 'invalid code' }) + let ok = false + for (const t of tokens) + if (safeEqual(code, t)) { ok = true; break } + if (!ok) + return res.status(401).json({ error: 'invalid code' }) + const sid = crypto.randomBytes(16).toString('hex') + sessions.set(sid, { ts: Date.now(), ip: clientIp(req) }) + setSessionCookie(res, sid) + res.json({ ok: true }) + }) + }, + requireAuth, + isValidSession, + sessions +} diff --git a/src/http/block/index.js b/src/http/block/index.js index 6d4cce5..7c61dcf 100644 --- a/src/http/block/index.js +++ b/src/http/block/index.js @@ -22,17 +22,20 @@ module.exports = { */ app.get('/block/:number', (req, res) => { let blockNumber = parseInt(req.params.number) + if (isNaN(blockNumber)) + return res.status(400).send({error: 'invalid block number'}) if (blocks.isOpen) { let block = {} try { block = blocks.read(blockNumber) } catch (e) { - return res.status(404).send({error: e.toString()}) + logr.error('block read failed', e) + return res.status(500).send({error: 'block read failed'}) } return res.send(block) } db.collection('blocks').findOne({ _id: blockNumber }, function (err, block) { - if (err) throw err + if (err) { logr.error('block query failed', err); return res.status(500).send({error: 'query failed'}) } if (!block) { res.sendStatus(404) return diff --git a/src/http/blog/index.js b/src/http/blog/index.js index 60b2c2e..7d1eeb2 100644 --- a/src/http/blog/index.js +++ b/src/http/blog/index.js @@ -5,14 +5,13 @@ module.exports = { * @apiName blog * @apiGroup Contents * - * @apiParam {String} username Username to retrieve blog of - * * @apiSuccess {Array} contents List of root contents authored by username */ app.get('/blog/:username', (req, res) => { let username = req.params.username db.collection('contents').find({ pa: null, author: username }, { sort: { ts: -1 }, limit: 50 }).toArray(function (err, contents) { + if (err) { logr.error('blog query failed', err); return res.status(500).send({error: 'query failed'}) } res.send(contents) }) }) @@ -32,6 +31,8 @@ module.exports = { let filterParam = req.params.filter let filter = filterParam.split(':') let filterBy = filter[1] + if (!filterBy) + return res.status(400).send({error: 'invalid filter'}) let filterAttrs = filterBy.split('&') let filterMap = {} @@ -49,8 +50,9 @@ module.exports = { if (key === 'sortBy') filterMap['sortBy'] = val else if (key === 'limit') { - filterMap['limit'] = parseInt(val) - limit = filterMap['limit'] + limit = parseInt(val) + if (isNaN(limit) || limit < 1 || limit > 100) + limit = 50 } } } @@ -60,12 +62,13 @@ module.exports = { else if (filterMap['sortBy'] === 'asc') ts = 1 db.collection('contents').find({ pa: null, author: username }, { sort: { ts: ts }, limit: limit }).toArray(function (err, contents) { + if (err) { logr.error('blog filter query failed', err); return res.status(500).send({error: 'query failed'}) } res.send(contents) }) }) /** - * @api {get} /blog/:username/:link User Blog (Continued) + * @api {get} /blog/:username/:author/:link User Blog (Continued) * @apiName blogContinued * @apiGroup Contents * @@ -94,9 +97,10 @@ module.exports = { { ts: { $lte: content.ts } } ] }, { sort: { ts: -1 }, limit: 50 }).toArray(function (err, contents) { + if (err) { logr.error('blog continued query failed', err); return res.status(500).send({error: 'query failed'}) } res.send(contents) }) }) }) } -} \ No newline at end of file +} diff --git a/src/http/content/index.js b/src/http/content/index.js index f5a621b..ef624fa 100644 --- a/src/http/content/index.js +++ b/src/http/content/index.js @@ -1,4 +1,20 @@ -const parallel = require('run-parallel') +const rateLimit = require('express-rate-limit') + +const contentLimiter = rateLimit({ + windowMs: 60000, + max: 60, + message: { error: 'too many requests' } +}) + +// Bounds the comment-tree expansion performed for /content/:author/:link so a +// crafted deep/wide comment tree cannot fan out into thousands of concurrent +// Mongo queries (depth alone was capped, total volume was not). +const MAX_COMMENT_DEPTH = 10 +const MAX_COMMENT_NODES = parseInt(process.env.CONTENT_MAX_COMMENTS) || 2000 +// also bound the size of the response body: the query budget alone still allows +// budget * comments_per_query entries on a wide tree +const MAX_COMMENT_RESULTS = parseInt(process.env.CONTENT_MAX_RESULTS) || 10000 +const CONTENT_QUERY_LIMIT = Math.min(1000, MAX_COMMENT_NODES) module.exports = { init: (app) => { @@ -29,7 +45,7 @@ module.exports = { * @apiSuccess {Double} dist Total curation rewards distributed in terms of 0.01 DTUBE * @apiSuccess {Object} comments Details of all comments */ - app.get('/content/:author/:link', (req, res) => { + app.get('/content/:author/:link', contentLimiter, (req, res) => { if (!req.params.author || typeof req.params.link !== 'string') { res.sendStatus(500) return @@ -47,35 +63,53 @@ module.exports = { return } post.comments = {} - function fillComments(posts, cb) { - if (!posts || posts.length === 0) { - cb() - return - } - let executions = [] - for (let i = 0; i < posts.length; i++) - executions.push(function (callback) { - db.collection('contents').find({ - pa: posts[i].author, - pp: posts[i].link - }).toArray(function (err, comments) { - for (let y = 0; y < comments.length; y++) + // Iterative breadth-first walk with a fixed worker pool and a hard + // budget on total nodes/queries, so a crafted deep+wide comment + // tree cannot fan out into thousands of concurrent Mongo queries. + const CONCURRENCY = 4 + const queue = [{ node: post, depth: 0 }] + let budget = MAX_COMMENT_NODES + let stored = 0 + let inFlight = 0 + let done = false + + const finish = () => { + if (done) return + done = true + res.send(post) + } + + const pump = () => { + while (!done && inFlight < CONCURRENCY && queue.length > 0 && budget > 0) { + const job = queue.shift() + budget-- + inFlight++ + db.collection('contents').find({ + pa: job.node.author, + pp: job.node.link + }, { limit: CONTENT_QUERY_LIMIT }).toArray(function (err, comments) { + inFlight-- + if (!err) { + for (let y = 0; y < comments.length; y++) { + if (stored >= MAX_COMMENT_RESULTS) break + stored++ post.comments[comments[y].author + '/' + comments[y].link] = comments[y] - fillComments(comments, function () { - callback(null, true) - }) - }) - i++ + } + if (job.depth + 1 <= MAX_COMMENT_DEPTH) + for (let y = 0; y < comments.length; y++) { + if (stored >= MAX_COMMENT_RESULTS) break + queue.push({ node: comments[y], depth: job.depth + 1 }) + } + } + if (inFlight === 0 && (queue.length === 0 || budget <= 0 || stored >= MAX_COMMENT_RESULTS)) + return finish() + pump() }) - - parallel(executions, function (err, results) { - if (err) throw err - cb(null, results) - }) + } + if (inFlight === 0 && (queue.length === 0 || budget <= 0 || stored >= MAX_COMMENT_RESULTS)) + finish() } - fillComments([post], function () { - res.send(post) - }) + pump() }) }) @@ -91,10 +125,16 @@ module.exports = { * * @apiSuccess {Array} contents List of filtered contents authored by username */ - app.get('/content/:filter', (req, res) => { + function isValidFilterValue(val) { + return /^[a-zA-Z0-9_\-.\u00C0-\u024F]+$/.test(val) + } + + app.get('/content/:filter', contentLimiter, (req, res) => { let filterParam = req.params.filter let filter = filterParam.split(':') let filterBy = filter[1] + if (!filterBy) + return res.status(400).send({error: 'invalid filter'}) let filterAttrs = filterBy.split('&') let filterMap = {} @@ -131,7 +171,7 @@ module.exports = { filterMap['tags'] = [] filterMap['tags'].push('all') } else if (key === 'limit') - filterMap['limit'] = Number.MAX_SAFE_INTEGER + filterMap['limit'] = 50 else if (key === 'tsrange') { filterMap['tsrange'] = [] filterMap['tsrange'].push(0) @@ -157,18 +197,22 @@ module.exports = { tags_ex.push(tags[i].substring(1, tags[i].length)) else tags_in.push(tags[i]) + + for (let v of authors_in.concat(authors_ex, tags_in, tags_ex)) + if (v !== 'all' && !isValidFilterValue(v)) + return res.status(400).send({error: 'invalid filter value'}) let limit = filterMap['limit'] - if(limit === -1 || isNaN(limit)) - limit = Number.MAX_SAFE_INTEGER + if (isNaN(limit) || limit < 1 || limit > 100) + limit = 50 let tsrange = filterMap['tsrange'] let tsfrom, tsto if (tsrange.length === 2) { tsfrom = parseInt(tsrange[0]) * 1000 tsto = parseInt(tsrange[1]) * 1000 - } else - return + } else + return res.status(400).send({error: 'invalid tsrange'}) if (authors.includes('all') && !tags.includes('all')) db.collection('contents').find({ diff --git a/src/http/dao/index.js b/src/http/dao/index.js index 4fcd080..5239417 100644 --- a/src/http/dao/index.js +++ b/src/http/dao/index.js @@ -1,4 +1,4 @@ -const dao = require("../../dao") +const dao = require('../../dao') const daoMaster = require('../../daoMaster') module.exports = { @@ -26,7 +26,8 @@ module.exports = { try { op = await db.collection('masterdao').findOne({_id: parseInt(id)}) } catch (e) { - return res.status(500).send({error: e.toString()}) + logr.error('master dao op query failed', e) + return res.status(500).send({error: 'query failed'}) } if (!op) return res.status(404).send({error: 'master dao operation not found'}) @@ -39,33 +40,34 @@ module.exports = { const query = {$and: []} const sort = {} switch (status) { - case 'queued': - query.$and.push({executed: {$exists: false}}) - query.$and.push({expiration: {$gt: new Date().getTime()}}) - sort.ts = -1 - break - case 'expired': - query.$and.push({executed: {$exists: false}}) - query.$and.push({expiration: {$lte: new Date().getTime()}}) - sort.ts = -1 - break - case 'executed': - query.$and.push({executed: {$exists: true}}) - query.$and.push({error: {$exists: false}}) - sort.executed = -1 - break - case 'errored': - query.$and.push({executed: {$exists: true}}) - query.$and.push({error: {$exists: true}}) - sort.executed = -1 - break - default: - return res.status(400).send({error: 'invalid status'}) + case 'queued': + query.$and.push({executed: {$exists: false}}) + query.$and.push({expiration: {$gt: new Date().getTime()}}) + sort.ts = -1 + break + case 'expired': + query.$and.push({executed: {$exists: false}}) + query.$and.push({expiration: {$lte: new Date().getTime()}}) + sort.ts = -1 + break + case 'executed': + query.$and.push({executed: {$exists: true}}) + query.$and.push({error: {$exists: false}}) + sort.executed = -1 + break + case 'errored': + query.$and.push({executed: {$exists: true}}) + query.$and.push({error: {$exists: true}}) + sort.executed = -1 + break + default: + return res.status(400).send({error: 'invalid status'}) } try { res.send(await db.collection('masterdao').find(query,{limit: 50, skip: parseInt(req.params.skip) || 0, sort: sort}).toArray()) } catch (e) { - res.status(500).send({error: e.toString()}) + logr.error('master dao ops query failed', e) + res.status(500).send({error: 'query failed'}) } }) @@ -85,7 +87,8 @@ module.exports = { try { res.send(await db.collection('proposals').find(query,{sort:{_id:sort}}).toArray()) } catch (e) { - res.status(500).send({error: e.toString()}) + logr.error('proposals query failed', e) + res.status(500).send({error: 'query failed'}) } }) } diff --git a/src/http/debug/index.js b/src/http/debug/index.js index 23fa4a8..45ad8df 100644 --- a/src/http/debug/index.js +++ b/src/http/debug/index.js @@ -1,17 +1,23 @@ +const rateLimit = require('express-rate-limit') +const { requireAuth } = require('../auth') + +const debugLimiter = rateLimit({ + windowMs: 60000, + max: 5, + message: { error: 'too many debug requests' } +}) + module.exports = { init: (app) => { - // get in-memory data (intensive) - app.get('/debug', (req, res) => { + app.get('/debug', debugLimiter, requireAuth(), (req, res) => { res.send({ - mempool: transaction.pool, consensus: { - possBlocks: consensus.possBlocks, - processed: consensus.processed, - validating: consensus.validating, + height: chain.getLatestBlock()._id, + possBlocksCount: consensus.possBlocks.length, }, chain: { - recentBlocks: chain.recentBlocks, - recentTxs: chain.recentTxs + recentBlocksCount: chain.recentBlocks.length, + recentTxsCount: Object.keys(chain.recentTxs).length } }) }) diff --git a/src/http/feed/index.js b/src/http/feed/index.js index 1db18e0..a8513ae 100644 --- a/src/http/feed/index.js +++ b/src/http/feed/index.js @@ -73,10 +73,16 @@ module.exports = { * * @apiSuccess {Array} posts Filtered list of root posts authored by followed accounts */ + function isValidFilterValue(val) { + return /^[a-zA-Z0-9_\-.\u00C0-\u024F]+$/.test(val) + } + app.get('/feed/:username/:filter', (req, res) => { let filterParam = req.params.filter let filter = filterParam.split(':') let filterBy = filter[1] + if (!filterBy) + return res.status(400).send({error: 'invalid filter'}) let filterAttrs = filterBy.split('&') let filterMap = {} @@ -139,18 +145,23 @@ module.exports = { tags_ex.push(tags[i].substring(1, tags[i].length)) else tags_in.push(tags[i]) + + const allVals = authors_in.concat(authors_ex, tags_in, tags_ex).filter(Boolean) + for (let v of allVals) + if (v !== 'all' && !isValidFilterValue(v)) + return res.status(400).send({error: 'invalid filter value'}) let limit = filterMap['limit'] - if(limit === -1 || isNaN(limit)) - limit = Number.MAX_SAFE_INTEGER + if (isNaN(limit) || limit < 1 || limit > 100) + limit = 50 let tsrange = filterMap['tsrange'] let tsfrom, tsto if (tsrange.length === 2) { tsfrom = parseInt(tsrange[0]) * 1000 tsto = parseInt(tsrange[1]) * 1000 - } else - return + } else + return res.status(400).send({error: 'invalid tsrange'}) if (authors.includes('all') && !tags.includes('all')) db.collection('accounts').findOne({ name: req.params.username }, function (err, account) { diff --git a/src/http/followers/index.js b/src/http/followers/index.js index b0d0f31..7753f0b 100644 --- a/src/http/followers/index.js +++ b/src/http/followers/index.js @@ -17,10 +17,10 @@ module.exports = { db.collection('accounts').findOne({ name: req.params.name }, function (err, account) { if (!account) res.sendStatus(404) else - if (account.followers) - res.send(account.followers) - else - res.send([]) + if (account.followers) + res.send(account.followers) + else + res.send([]) }) }) } diff --git a/src/http/follows/index.js b/src/http/follows/index.js index 5a5ffab..d4e9b14 100644 --- a/src/http/follows/index.js +++ b/src/http/follows/index.js @@ -17,10 +17,10 @@ module.exports = { db.collection('accounts').findOne({ name: req.params.name }, function (err, account) { if (!account) res.sendStatus(404) else - if (account.follows) - res.send(account.follows) - else - res.send([]) + if (account.follows) + res.send(account.follows) + else + res.send([]) }) }) diff --git a/src/http/hot/index.js b/src/http/hot/index.js index 7de9bd7..9562257 100644 --- a/src/http/hot/index.js +++ b/src/http/hot/index.js @@ -48,10 +48,16 @@ module.exports = { * * @apiSuccess {Object[]} contents List of ranked hot contents filtered */ + function isValidFilterValue(val) { + return /^[a-zA-Z0-9_\-.\u00C0-\u024F]+$/.test(val) + } + app.get('/hot/:filter', (req, res) => { let filterParam = req.params.filter let filter = filterParam.split(':') let filterBy = filter[1] + if (!filterBy) + return res.status(400).send({error: 'invalid filter'}) let filterAttrs = filterBy.split('&') let filterMap = {} @@ -81,7 +87,7 @@ module.exports = { filterMap['tags'] = [] filterMap['tags'].push('all') } else if (key === 'limit') - filterMap['limit'] = Number.MAX_SAFE_INTEGER + filterMap['limit'] = 50 } let tags = filterMap['tags'] @@ -93,12 +99,16 @@ module.exports = { tags_ex.push(tags[i].substring(1, tags[i].length)) else tags_in.push(tags[i]) + + for (let v of tags_in.concat(tags_ex)) + if (v !== 'all' && !isValidFilterValue(v)) + return res.status(400).send({error: 'invalid filter value'}) let limit = filterMap['limit'] - if(limit === -1 || isNaN(limit)) - limit = Number.MAX_SAFE_INTEGER + if (isNaN(limit) || limit < 1 || limit > 100) + limit = 50 let minTs = new Date().getTime() - rankings.types['hot'].halfLife*rankings.expireFactor - if (tags.includes('all')) + if (tags.includes('all')) db.collection('contents').find( { $and: [ @@ -108,7 +118,7 @@ module.exports = { { ts: {'$gt': minTs} } ] }, - {sort: {ts: -1}}).toArray(function(err, contents) { + {sort: {ts: -1}, limit: 5000}).toArray(function(err, contents) { for (let i = 0; i < contents.length; i++) { contents[i].score = 0 contents[i].ups = 0 @@ -151,7 +161,7 @@ module.exports = { { ts: {'$gt': minTs} } ] }, - {sort: {ts: -1}}).toArray(function(err, contents) { + {sort: {ts: -1}, limit: 5000}).toArray(function(err, contents) { for (let i = 0; i < contents.length; i++) { contents[i].score = 0 contents[i].ups = 0 diff --git a/src/http/image/index.js b/src/http/image/index.js index 0493e3f..1739969 100755 --- a/src/http/image/index.js +++ b/src/http/image/index.js @@ -1,6 +1,13 @@ const sharp = require('sharp') const fetch = require('node-fetch-commonjs') -logr = require('../../logger.js') +const { URL } = require('url') +const net = require('net') +const http = require('http') +const https = require('https') +const tls = require('tls') +const rateLimit = require('express-rate-limit') +const { isPrivateURL, resolveAndPin, checkRebinding } = require('../ssrf') +const logr = require('../../logger.js') const QUALITY = 95 const AVATAR_WIDTH = { @@ -9,8 +16,19 @@ const AVATAR_WIDTH = { large: 512 } const DEFAULT_AVATAR = 'https://steemitimages.com/DQmb2HNSGKN3pakguJ4ChCRjgkVuDN9WniFRPmrxoJ4sjR4' -const CACHE_SIZE = parseInt(process.env.IMG_CACHE_SIZE) || -1 +const CACHE_SIZE = Math.max(parseInt(process.env.IMG_CACHE_SIZE) || 52428800, -1) const CACHE_TIME = parseInt(process.env.IMG_CACHE_TIME) || 900000 // 15 minutes default +// Cap remote image downloads to bound memory: sharp decodes into RAM, so an +// oversized/decompression-bomb input could OOM the node. +const MAX_DOWNLOAD_BYTES = parseInt(process.env.IMG_MAX_BYTES) || 10 * 1024 * 1024 +const MAX_INPUT_PIXELS = parseInt(process.env.IMG_MAX_PIXELS) || 20 * 1000 * 1000 + +const imageLimiter = rateLimit({ + windowMs: 60000, + max: 60, + message: { error: 'too many requests' } +}) + let imageCache = { avatar: { @@ -20,6 +38,7 @@ let imageCache = { }, cover: {} } +let imageCacheBytes = 0 module.exports = { init: (app) => { @@ -34,11 +53,11 @@ module.exports = { * @apiSuccess {Binary} image The image file of the avatar * @apiSampleRequest off */ - app.get('/image/avatar/:name/:size?', (req, res) => { + app.get('/image/avatar/:name/:size?', imageLimiter, (req, res) => { if (!req.params.name) return res.status(400).send({error: 'username is required'}) let size = req.params.size || 'medium' - if (!imageCache.avatar[size] || size.startsWith('default_') || size == '') + if (!imageCache.avatar[size] || size.startsWith('default_') || size === '') size = 'medium' // Return cached image if available @@ -70,11 +89,14 @@ module.exports = { fetchAndRespondImage(imageUrl,res,AVATAR_WIDTH[size],AVATAR_WIDTH[size],(imgJson) => { if (isDefault) { - imageCache.avatar[size][req.params.name] = { t: new Date().getTime() } - imageCache.avatar['default_'+size] = imgJson - } else if (JSON.stringify(imageCache).length < CACHE_SIZE) imageCache.avatar[size][req.params.name] = { - t: new Date().getTime(), - d: imgJson + const key = 'default_'+size + if (!imageCache.avatar[key]) + imageCacheBytes += JSON.stringify(imgJson).length + imageCache.avatar[key] = imgJson + } else if (imageCacheBytes < CACHE_SIZE) { + const entry = { t: new Date().getTime(), d: imgJson } + imageCache.avatar[size][req.params.name] = entry + imageCacheBytes += JSON.stringify(entry).length } }) }) @@ -90,7 +112,7 @@ module.exports = { * @apiSuccess {Binary} image The image file of the cover * @apiSampleRequest off */ - app.get('/image/cover/:name',(req,res) => { + app.get('/image/cover/:name', imageLimiter, (req,res) => { if (!req.params.name) return res.status(400).send({error: 'username is required'}) if (imageCache.cover[req.params.name] && imageCache.cover[req.params.name].d) { @@ -107,47 +129,136 @@ module.exports = { return res.status(404).send({error: 'invalid cover image url'}) fetchAndRespondImage(imageUrl,res,2048,512,(imgJson) => { - if (JSON.stringify(imageCache).length < CACHE_SIZE) imageCache.cover[req.params.name] = { - t: new Date().getTime(), - d: imgJson + if (imageCacheBytes < CACHE_SIZE) { + const entry = { t: new Date().getTime(), d: imgJson } + imageCache.cover[req.params.name] = entry + imageCacheBytes += JSON.stringify(entry).length } }) }) }) app.get('/image/cachesize',(req,res) => { - res.send({size: JSON.stringify(imageCache).length}) + res.send({size: imageCacheBytes}) }) // cleanup cache setInterval(() => { let timeNow = new Date().getTime() for (let s in imageCache.avatar) if (!s.startsWith('default_')) for (let u in imageCache.avatar[s]) - if (timeNow - imageCache.avatar[s][u].t > CACHE_TIME) + if (timeNow - imageCache.avatar[s][u].t > CACHE_TIME) { + imageCacheBytes -= JSON.stringify(imageCache.avatar[s][u]).length delete imageCache.avatar[s][u] + } for (let u in imageCache.cover) - if (timeNow - imageCache.cover[u].t > CACHE_TIME) + if (timeNow - imageCache.cover[u].t > CACHE_TIME) { + imageCacheBytes -= JSON.stringify(imageCache.cover[u]).length delete imageCache.cover[u] + } },30000) } } -async function fetchAndRespondImage(imageUrl,res,width,height,cacher) { +async function fetchAndRespondImage(imageUrl,res,width,height,cacher,redirectsRemaining = 5) { try { - let imgFetch = await fetch(imageUrl) - let buffer = await imgFetch.buffer() + if (await isPrivateURL(imageUrl)) + return res.status(400).send({error: 'invalid image url'}) + const parsed = new URL(imageUrl) + const pinnedIp = await resolveAndPin(parsed.hostname) + if (!pinnedIp) + return res.status(400).send({error: 'could not resolve host'}) + if (await isPrivateURL('http://' + pinnedIp)) + return res.status(400).send({error: 'invalid image url'}) + if (!(await checkRebinding(parsed.hostname, pinnedIp))) + return res.status(400).send({error: 'dns rebinding detected'}) + // Keep original hostname for SNI/TLS; pin IP via custom agent lookup + const isHttps = parsed.protocol === 'https:' + const pinAgent = isHttps + ? new https.Agent({ createConnection: (opts, cb) => { + opts.servername = parsed.hostname + opts.host = pinnedIp + return tls.connect(opts, cb) + }}) + : new http.Agent({ createConnection: (opts, cb) => { + opts.host = pinnedIp + return net.createConnection(opts, cb) + }}) + const controller = new AbortController() + const timeout = setTimeout(() => controller.abort(), 5000) + let imgFetch + try { + imgFetch = await fetch(imageUrl, { + signal: controller.signal, + redirect: 'manual', + agent: pinAgent + }) + } finally { + clearTimeout(timeout) + } + if (imgFetch.status >= 300 && imgFetch.status < 400) { + if (redirectsRemaining <= 0) + return res.status(400).send({error: 'too many redirects'}) + + const location = imgFetch.headers.get('location') + if (location) { + // Resolve relative redirects against the original URL + const resolvedLocation = new URL(location, imageUrl).toString() + if (await isPrivateURL(resolvedLocation)) + return res.status(400).send({error: 'invalid image url'}) + + const locParsed = new URL(resolvedLocation) + const locPinned = await resolveAndPin(locParsed.hostname) + if (!locPinned || !(await checkRebinding(locParsed.hostname, locPinned))) + return res.status(400).send({error: 'dns rebinding detected on redirect'}) + + return fetchAndRespondImage(resolvedLocation, res, width, height, cacher, redirectsRemaining - 1) + } + return res.status(400).send({error: 'redirect not allowed'}) + } + const contentLength = parseInt(imgFetch.headers.get('content-length') || '0', 10) + if (contentLength > MAX_DOWNLOAD_BYTES) + return res.status(400).send({error: 'image too large'}) + + let buffer = await readCappedBody(imgFetch, MAX_DOWNLOAD_BYTES) + if (!buffer) + return res.status(400).send({error: 'image too large'}) let img = await resizeImage(buffer,width,height) imageResponse(res,img) await cacher(await img.toJSON()) } catch (e) { - await logr.debug(await e); - await res.status(500).send({error: 'errored while retrieving avatar'}) + logr.debug(e) + res.status(500).send({error: 'errored while retrieving avatar'}) } } +// Reads at most maxBytes from the response body, aborting as soon as the cap is +// exceeded so a lying/omitted Content-Length cannot force an unbounded buffer. +function readCappedBody(resp, maxBytes) { + return new Promise((resolve, reject) => { + const chunks = [] + let total = 0 + let done = false + const finish = (err, val) => { + if (done) return + done = true + if (err) reject(err); else resolve(val) + } + resp.body.on('data', (chunk) => { + total += chunk.length + if (total > maxBytes) { + resp.body.destroy() + return finish(null, null) + } + chunks.push(chunk) + }) + resp.body.on('end', () => finish(null, Buffer.concat(chunks))) + resp.body.on('error', (err) => finish(err)) + }) +} + function resizeImage(buf,width,height) { return new Promise((rs,rj) => { - sharp(buf) + sharp(buf, { limitInputPixels: MAX_INPUT_PIXELS, failOn: 'error' }) .resize(width,height) .toFormat('png',{quality: QUALITY}) .toBuffer((err, data) => { @@ -158,7 +269,7 @@ function resizeImage(buf,width,height) { } function imageResponse(res,img) { - res.setHeader('Cache-Control', 'public, max-age=3600000') + res.setHeader('Cache-Control', 'no-store') res.setHeader('Content-Type', 'image/png') res.send(img) } diff --git a/src/http/index.js b/src/http/index.js index e7e3373..3b61878 100644 --- a/src/http/index.js +++ b/src/http/index.js @@ -1,15 +1,56 @@ const http_port = process.env.HTTP_PORT || 3001 -const http_host = process.env.HTTP_HOST || "0.0.0.0" +const http_host = process.env.HTTP_HOST || '127.0.0.1' const express = require('express') const cors = require('cors') const bodyParser = require('body-parser') +const rateLimit = require('express-rate-limit') const fs = require('fs') +const globalLimiter = rateLimit({ + windowMs: 1000, + max: 50, + message: { error: 'too many requests' } +}) + +// Express accepts a hop count (number), a boolean, or a keyword / IP-list +// string; anything else is parsed as an IP by proxy-addr and throws a cryptic +// "invalid IP address" at startup, killing the node before it listens. +// Normalise the common spellings here so e.g. TRUST_PROXY=true fails with a +// clear message instead. +// "Trust every proxy" (express's boolean `true`) is deliberately refused: it +// makes X-Forwarded-For spoofable, which defeats the rate limiting and the +// session address binding that rely on req.ip. +function parseTrustProxy(raw) { + if (raw === undefined || raw === null) return undefined + const v = String(raw).trim().toLowerCase() + if (v === '' || v === '0' || v === 'false' || v === 'no' || v === 'off') return undefined + if (/^\d+$/.test(v)) return parseInt(v, 10) + if (v === 'loopback' || v === 'linklocal' || v === 'uniquelocal') return v + if (v === 'true' || v === 'yes' || v === 'on') + throw new Error("TRUST_PROXY: refusing '" + raw + "' (trusting every proxy makes " + + "X-Forwarded-For spoofable); use a hop count (e.g. TRUST_PROXY=1) or loopback|linklocal|uniquelocal") + return v +} + let http = { init: () => { let app = express() - app.use(cors()) - app.use(bodyParser.json()) + // Only honour X-Forwarded-* when explicitly told the node sits behind a + // trusted proxy, otherwise req.ip (used for rate limiting and session + // address binding) would be client-spoofable. + try { + const trustProxy = parseTrustProxy(process.env.TRUST_PROXY) + if (trustProxy !== undefined) + app.set('trust proxy', trustProxy) + } catch (error) { + logr.fatal(error.message) + process.exit(1) + } + app.use(cors({ + origin: process.env.CORS_ORIGIN || false + })) + app.use(bodyParser.json({ limit: '1mb' })) + app.use(globalLimiter) // any folder in the /http/ folder is a different api endpoint let endpoints = fs.readdirSync(__dirname, { withFileTypes: true }) @@ -20,11 +61,12 @@ let http = { require(__dirname+'/'+endpoints[i]).init(app) logr.debug('Initialized API endpoint /'+endpoints[i]) } catch (error) { - logr.error('Failed to load API endpoint /'+endpoints[i]) + logr.error('Failed to load API endpoint /'+endpoints[i]+': '+error.message) } app.listen(http_port, http_host, () => logr.info('Listening http on port: ' + http_port)) } } +http.parseTrustProxy = parseTrustProxy module.exports = http diff --git a/src/http/leader/index.js b/src/http/leader/index.js index 50fb8af..c80642e 100644 --- a/src/http/leader/index.js +++ b/src/http/leader/index.js @@ -26,7 +26,7 @@ module.exports = { if (!req.params.account) res.status(404).send({error: 'account is required'}) db.collection('accounts').findOne({name: req.params.account}, (e,acc) => { - if (e) return res.status(500).send(e) + if (e) { logr.error('leader query failed', e); return res.status(500).send({error: 'query failed'}) } if (!acc) return res.status(404).send({error: 'account does not exist'}) if (!leaderStats.leaders[acc.name] || (!acc.pub_leader && !leaderStats.leaders[acc.name].last)) return res.status(404).send({error: 'account does not have any leader-related activities'}) @@ -35,8 +35,8 @@ module.exports = { balance: acc.balance, node_appr: acc.node_appr, pub_leader: acc.pub_leader, - subs: acc.followers.length, - subbed: acc.follows.length, + subs: acc.followers ? acc.followers.length : 0, + subbed: acc.follows ? acc.follows.length : 0, sinceTs: leaderStats.leaders[acc.name].sinceTs, sinceBlock: leaderStats.leaders[acc.name].sinceBlock, produced: leaderStats.leaders[acc.name].produced, diff --git a/src/http/logs/index.js b/src/http/logs/index.js new file mode 100644 index 0000000..0eb1a29 --- /dev/null +++ b/src/http/logs/index.js @@ -0,0 +1,291 @@ +const logBuffer = require('../../logBuffer') +const crypto = require('crypto') +const { requireAuth, isValidSession } = require('../auth') + +const LOG_PAGE_ENABLED = process.env.LOG_PAGE !== '0' + +const VALID_LEVELS = ['TRACE', 'DEBUG', 'PERF', 'ECON', 'CONS', 'INFO', 'WARN', 'ERROR', 'FATAL'] + +function isAdmin(req) { + // delegate the session check to the shared helper so the IP binding is + // enforced identically here and in requireAuth() + if (isValidSession(req)) + return true + + const headerToken = req.headers['authorization'] ? req.headers['authorization'].replace('Bearer ', '') : '' + const queryToken = req.query.token || '' + const token = headerToken || queryToken + const vars = ['ADMIN_TOKEN', 'LOG_ADMIN_TOKEN', 'MINE_TOKEN', 'DEBUG_TOKEN', 'RECOVER_TOKEN'] + for (const v of vars) { + const expected = process.env[v] + if (token && expected) + try { + if (crypto.timingSafeEqual(Buffer.from(token), Buffer.from(expected))) + return true + } catch {} + + } + return false +} + +module.exports = { + init: (app) => { + if (!LOG_PAGE_ENABLED) return + + app.get('/logs', requireAuth(), (req, res) => { + res.set('Content-Type', 'text/html; charset=utf-8') + res.set('Content-Security-Policy', [ + 'default-src \'none\'', + 'style-src \'self\' \'unsafe-inline\' https://cdn.jsdelivr.net', + 'img-src \'self\' data:', + 'script-src \'self\' \'unsafe-inline\'', + 'connect-src \'self\'', + 'form-action \'none\'', + 'frame-ancestors \'none\'', + 'base-uri \'none\'' + ].join('; ')) + res.set('X-Content-Type-Options', 'nosniff') + res.set('Referrer-Policy', 'no-referrer') + res.send(renderPage()) + }) + + app.get('/logs/stream', (req, res) => { + if (!isAdmin(req)) + return res.sendStatus(401) + + const levelParam = Array.isArray(req.query.level) ? req.query.level.slice(0, VALID_LEVELS.length).join(',') : req.query.level + const filterLevel = levelParam ? levelParam.split(',').filter(l => VALID_LEVELS.includes(l)) : null + const ss = req.query.search + const filterSearch = typeof ss === 'string' && ss.length < 200 ? ss : null + + res.writeHead(200, { + 'Content-Type': 'text/event-stream', + 'Cache-Control': 'no-store', + 'Connection': 'keep-alive', + 'X-Accel-Buffering': 'no' + }) + + const initial = logBuffer.getLogs({ level: filterLevel, search: filterSearch, full: true }) + res.write(`data: ${JSON.stringify({ type: 'init', logs: initial })}\n\n`) + + const onLog = (entry) => { + if (filterLevel && !filterLevel.includes(entry.level)) return + if (filterSearch && !entry.message.toLowerCase().includes(filterSearch.toLowerCase())) return + res.write(`data: ${JSON.stringify({ type: 'log', entry })}\n\n`) + } + + logBuffer.emitter.on('log', onLog) + + const keepAlive = setInterval(() => res.write(':keepalive\n\n'), 15000) + + req.on('close', () => { + logBuffer.emitter.off('log', onLog) + clearInterval(keepAlive) + }) + }) + } +} + +function renderPage() { + return ` + + + + +Avalon Node Logs + + + + + + +

+ ${VALID_LEVELS.map(l => ``).join('')} +

+ + + + +

+ +

+ + + +` +} diff --git a/src/http/mineBlock/index.js b/src/http/mineBlock/index.js index e81b18c..747aa0b 100644 --- a/src/http/mineBlock/index.js +++ b/src/http/mineBlock/index.js @@ -1,8 +1,15 @@ +const rateLimit = require('express-rate-limit') +const { requireAuth } = require('../auth') + +const mineLimiter = rateLimit({ + windowMs: 3000, + max: 1, + message: { error: 'too many mine requests' } +}) + module.exports = { init: (app) => { - // this suggests the node to produce a block and submit it - app.get('/mineBlock', (req, res) => { - delete p2p.recovering + app.get('/mineBlock', mineLimiter, requireAuth(), (req, res) => { res.send(chain.getLatestBlock()._id.toString()) chain.mineBlock(function (error, finalBlock) { if (error) diff --git a/src/http/new/index.js b/src/http/new/index.js index e27c2b0..056439d 100644 --- a/src/http/new/index.js +++ b/src/http/new/index.js @@ -59,10 +59,12 @@ module.exports = { let filterParam = req.params.filter let filter = filterParam.split(':') let filterBy = filter[1] + if (!filterBy) + return res.status(400).send({error: 'invalid filter'}) let filterAttrs = [] - if (filterBy !== null) { + if (filterBy !== null) filterAttrs = filterBy.split('&') - } + let filterMap = {} let defaultKeys = ['authors', 'tags', 'limit', 'tsrange'] @@ -128,16 +130,16 @@ module.exports = { let limit = filterMap['limit'] - if(limit === -1 || isNaN(limit)) - limit = Number.MAX_SAFE_INTEGER + if (isNaN(limit) || limit < 1 || limit > 100) + limit = 50 let tsrange = filterMap['tsrange'] let tsfrom, tsto if (tsrange.length === 2) { tsfrom = parseInt(tsrange[0]) * 1000 tsto = parseInt(tsrange[1]) * 1000 - } else - return + } else + return res.status(400).send({error: 'invalid tsrange'}) if (authors.includes('all') && !tags.includes('all')) db.collection('contents').find({ diff --git a/src/http/notifications/index.js b/src/http/notifications/index.js index ed4d8ca..20b9ae7 100644 --- a/src/http/notifications/index.js +++ b/src/http/notifications/index.js @@ -16,6 +16,7 @@ module.exports = { return } db.collection('notifications').find({ u: req.params.name }, { sort: { ts: -1 }, limit: 200 }).toArray(function (err, notifs) { + if (err) { logr.error('notifications query failed', err); return res.status(500).send({error: 'query failed'}) } if (!notifs) res.sendStatus(404) else res.send(notifs) }) diff --git a/src/http/oembed/index.js b/src/http/oembed/index.js index f7f5239..7572b4e 100644 --- a/src/http/oembed/index.js +++ b/src/http/oembed/index.js @@ -1,23 +1,33 @@ const { extract } = require('oembed-parser') +const rateLimit = require('express-rate-limit') +const { isPrivateURL } = require('../ssrf') + +const oembedLimiter = rateLimit({ + windowMs: 60000, + max: 20, + message: { error: 'too many requests' } +}) module.exports = { init: (app) => { - // get oembed for any url - /** - * @api {get} /oembed/:url OEmbed - * @apiName oembed - * @apiGroup External - * - * @apiParam {String} url The URL to query oembed data of - * - * @apiSuccess {Object} info The oembed data - */ - app.get('/oembed/:url', (req, res) => { - if (!req.params.url) { + app.get('/oembed/:url', oembedLimiter, async (req, res) => { + const url = req.params.url + if (!url) { res.sendStatus(500) return } - extract(req.params.url).then((data) => { + // Only http(s) URLs are accepted. The user-supplied URL is passed to + // oembed-parser, which never fetches it: it is matched against the + // bundled provider list and then forwarded as a `?url=` query + // parameter to the provider's hard-coded oEmbed endpoint. Pinning or + // rewriting the URL here would break provider matching (and thus the + // endpoint), so the check stays on the raw URL to reject internal / + // non-routable targets. + if (!/^https?:\/\//i.test(url) || await isPrivateURL(url)) { + res.status(400).send({error: 'invalid url'}) + return + } + extract(url).then((data) => { res.send(data) }).catch(() => { res.sendStatus(404) diff --git a/src/http/opengraph/index.js b/src/http/opengraph/index.js index 5dd005a..d179938 100644 --- a/src/http/opengraph/index.js +++ b/src/http/opengraph/index.js @@ -1,26 +1,112 @@ const ogs = require('open-graph-scraper') +const { URL } = require('url') +const net = require('net') +const http = require('http') +const https = require('https') +const tls = require('tls') +const fetch = require('node-fetch-commonjs') +const rateLimit = require('express-rate-limit') +const { isPrivateURL, isPrivateIP, resolveAndPin } = require('../ssrf') + +const ogLimiter = rateLimit({ + windowMs: 60000, + max: 20, + message: { error: 'too many requests' } +}) + +const MAX_REDIRECTS = 5 +const TIMEOUT = 5000 + +// got (used internally by open-graph-scraper) requires the agent to be an object +// keyed by protocol. Both agents dial the already-validated IP while keeping the +// original hostname for the Host header and TLS SNI, so certificate validation +// keeps working (rewriting the URL host to the IP would break every HTTPS site). +function pinnedAgents(pinnedIp, hostname) { + return { + http: new http.Agent({ createConnection: (opts, cb) => { + opts.host = pinnedIp + return net.createConnection(opts, cb) + } }), + https: new https.Agent({ createConnection: (opts, cb) => { + opts.host = pinnedIp + // SNI/cert validation must still see the real hostname + opts.servername = hostname + return tls.connect(opts, cb) + } }) + } +} + +// Walks the redirect chain manually so every hop is validated and IP-pinned, +// then hands the final URL to ogs with followRedirect:false. Without that flag +// the scraper could chase a redirect our validation never saw (e.g. a +// UA-dependent 302 to http://169.254.169.254/ that only appears on a re-request). +// Returns { url, agent } ready to be passed to ogs. +async function resolveSafeTarget(urlStr) { + let currentUrl = urlStr + let lastAgent = null + for (let i = 0; i <= MAX_REDIRECTS; i++) { + if (await isPrivateURL(currentUrl)) + throw new Error('blocked private URL') + const parsed = new URL(currentUrl) + if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') + throw new Error('blocked protocol') + const pinnedIp = await resolveAndPin(parsed.hostname) + if (!pinnedIp) throw new Error('could not resolve host') + if (isPrivateIP(pinnedIp)) throw new Error('blocked private URL') + const agents = pinnedAgents(pinnedIp, parsed.hostname) + lastAgent = agents + + // node-fetch takes a single agent; got (inside ogs) takes the + // {http,https} object. Hence both shapes are kept. + const singleAgent = parsed.protocol === 'https:' ? agents.https : agents.http + const controller = new AbortController() + const timeout = setTimeout(() => controller.abort(), TIMEOUT) + let resp + try { + resp = await fetch(currentUrl, { + signal: controller.signal, + redirect: 'manual', + agent: singleAgent, + headers: { 'user-agent': 'facebookexternalhit/1.1 (+https://d.tube)' } + }) + } finally { + clearTimeout(timeout) + } + + if (resp.status >= 300 && resp.status < 400) { + if (i === MAX_REDIRECTS) throw new Error('too many redirects') + const location = resp.headers.get('location') + if (!location) throw new Error('redirect with no location') + currentUrl = new URL(location, currentUrl).href + continue + } + return { url: currentUrl, agent: lastAgent } + } + throw new Error('too many redirects') +} module.exports = { init: (app) => { - // get open graph data for any url - /** - * @api {get} /opengraph/:url OpenGraph - * @apiName opengraph - * @apiGroup External - * - * @apiParam {String} url The URL to query opengraph data of - * - * @apiSuccess {Object} info The opengraph data - */ - app.get('/opengraph/:url', (req, res) => { + app.get('/opengraph/:url', ogLimiter, async (req, res) => { if (!req.params.url) { res.sendStatus(500) return } - ogs({ url: req.params.url, headers: { 'user-agent': 'facebookexternalhit/1.1 (+https://d.tube)' } }, function (error, results) { - if (error) res.sendStatus(404) - else res.send(results) - }) + try { + const target = await resolveSafeTarget(req.params.url) + ogs({ + url: target.url, + agent: target.agent, + timeout: TIMEOUT, + followRedirect: false, + headers: { 'user-agent': 'facebookexternalhit/1.1 (+https://d.tube)' } + }, function (error, results) { + if (error) res.sendStatus(404) + else res.send(results) + }) + } catch { + res.status(400).send({error: 'invalid url'}) + } }) } } diff --git a/src/http/p2p/index.js b/src/http/p2p/index.js index 0bcc82e..6041f48 100644 --- a/src/http/p2p/index.js +++ b/src/http/p2p/index.js @@ -1,5 +1,15 @@ +const rateLimit = require('express-rate-limit') + +const p2pLimiter = rateLimit({ + windowMs: 1000, + max: 20, + message: { error: 'too many requests' } +}) + module.exports = { init: (app) => { + app.use('/p2p', p2pLimiter) + /** * @api {get} /p2p P2PVideos * @apiName p2p @@ -8,7 +18,7 @@ module.exports = { * @apiSuccess {Object[]} contents List of new p2p contents */ app.get('/p2p', (req, res) => { - db.collection('contents').find({$and: [{pa: null }, {$or: [{"json.files.ipfs": {$ne: null}},{"json.files.btfs": {$ne: null}}, {"json.files.sia": { $ne: null}}]}]}, { sort: { ts: -1 }, limit: 50 }).toArray(function (err, contents) { + db.collection('contents').find({$and: [{pa: null }, {$or: [{'json.files.ipfs': {$ne: null}},{'json.files.btfs': {$ne: null}}, {'json.files.sia': { $ne: null}}]}]}, { sort: { ts: -1 }, limit: 50 }).toArray(function (err, contents) { res.send(contents) }) }) @@ -37,7 +47,7 @@ module.exports = { db.collection('contents').find({ $and: [ { pa: null }, - {$or: [{"json.files.ipfs": {$ne: null}},{"json.files.btfs": {$ne: null}}, {"json.files.sia": { $ne: null}}]}, + {$or: [{'json.files.ipfs': {$ne: null}},{'json.files.btfs': {$ne: null}}, {'json.files.sia': { $ne: null}}]}, { ts: { $lte: content.ts } } ] }, { sort: { ts: -1 }, limit: 50 }).toArray(function (err, contents) { @@ -60,10 +70,12 @@ module.exports = { let filterParam = req.params.filter let filter = filterParam.split(':') let filterBy = filter[1] + if (!filterBy) + return res.status(400).send({error: 'invalid filter'}) let filterAttrs = [] - if (filterBy !== null) { + if (filterBy !== null) filterAttrs = filterBy.split('&') - } + let filterMap = {} let defaultKeys = ['authors', 'tags', 'limit', 'tsrange'] @@ -129,23 +141,23 @@ module.exports = { let limit = filterMap['limit'] - if(limit === -1 || isNaN(limit)) - limit = Number.MAX_SAFE_INTEGER + if (isNaN(limit) || limit < 1 || limit > 100) + limit = 50 let tsrange = filterMap['tsrange'] let tsfrom, tsto if (tsrange.length === 2) { tsfrom = parseInt(tsrange[0]) * 1000 tsto = parseInt(tsrange[1]) * 1000 - } else - return + } else + return res.status(400).send({error: 'invalid tsrange'}) if (authors.includes('all') && !tags.includes('all')) db.collection('contents').find({ $and: [ { pa: null }, { author: { $nin : authors_ex } }, - {$or: [{"json.files.ipfs": {$ne: null}},{"json.files.btfs": {$ne: null}}, {"json.files.sia": { $ne: null}}]}, + {$or: [{'json.files.ipfs': {$ne: null}},{'json.files.btfs': {$ne: null}}, {'json.files.sia': { $ne: null}}]}, { $or: [ { @@ -174,7 +186,7 @@ module.exports = { { pa: null }, { author: { $in : authors_in } }, { author: { $nin : authors_ex } }, - {$or: [{"json.files.ipfs": {$ne: null}},{"json.files.btfs": {$ne: null}}, {"json.files.sia": { $ne: null}}]}, + {$or: [{'json.files.ipfs': {$ne: null}},{'json.files.btfs': {$ne: null}}, {'json.files.sia': { $ne: null}}]}, { $or: [ { @@ -201,7 +213,7 @@ module.exports = { db.collection('contents').find({ $and: [ { pa: null }, - {$or: [{"json.files.ipfs": {$ne: null}},{"json.files.btfs": {$ne: null}}, {"json.files.sia": {$ne: null}}]}, + {$or: [{'json.files.ipfs': {$ne: null}},{'json.files.btfs': {$ne: null}}, {'json.files.sia': {$ne: null}}]}, { author: { $nin : authors_ex } }, { 'json.tag': { $nin: tags_ex } }, { votes: { $elemMatch: { tag: { $nin: tags_ex } } } }, @@ -217,7 +229,7 @@ module.exports = { { pa: null }, { author: { $in : authors_in } }, { author: { $nin : authors_ex } }, - {$or: [{"json.files.ipfs": {$ne: null}},{"json.files.btfs": {$ne: null}}, {"json.files.sia": { $ne: null}}]}, + {$or: [{'json.files.ipfs': {$ne: null}},{'json.files.btfs': {$ne: null}}, {'json.files.sia': { $ne: null}}]}, { 'json.tag': { $nin: tags_ex } }, { votes: { $elemMatch: { tag: { $nin: tags_ex } } } }, { ts: { $gte: tsfrom } }, diff --git a/src/http/proposal/index.js b/src/http/proposal/index.js index 50cfeba..e900526 100644 --- a/src/http/proposal/index.js +++ b/src/http/proposal/index.js @@ -1,5 +1,3 @@ -const dao = require("../../dao") - module.exports = { init: (app) => { app.get('/proposal/:id', async (req,res) => { @@ -10,7 +8,8 @@ module.exports = { try { proposal = await db.collection('proposals').findOne({_id: parseInt(id)}) } catch (e) { - return res.status(500).send({error: e.toString()}) + logr.error('proposal query failed', e) + return res.status(500).send({error: 'query failed'}) } if (!proposal) return res.status(404).send({error: 'proposal not found'}) @@ -29,7 +28,8 @@ module.exports = { try { res.send(await db.collection('proposalVotes').find(query).toArray()) } catch (e) { - return res.status(500).send({error: e.toString()}) + logr.error('proposal votes query failed', e) + return res.status(500).send({error: 'query failed'}) } }) @@ -42,7 +42,8 @@ module.exports = { try { res.send(await db.collection('proposalVotes').find(query).toArray()) } catch (e) { - return res.status(500).send({error: e.toString()}) + logr.error('proposal votes by voter query failed', e) + return res.status(500).send({error: 'query failed'}) } }) } diff --git a/src/http/rank/index.js b/src/http/rank/index.js index 4d56920..28e6cc9 100644 --- a/src/http/rank/index.js +++ b/src/http/rank/index.js @@ -49,8 +49,10 @@ module.exports = { aggregation.push(matching) db.collection('accounts').aggregate(aggregation).toArray((e,r) => { - if (e) - return res.status(500).send(e) + if (e) { + logr.error('rank query failed', e) + return res.status(500).send({error: 'query failed'}) + } if (req.params.key !== 'leaders') return res.send(r) else { diff --git a/src/http/recover/index.js b/src/http/recover/index.js index 61a3e81..0b20127 100644 --- a/src/http/recover/index.js +++ b/src/http/recover/index.js @@ -1,8 +1,18 @@ +const rateLimit = require('express-rate-limit') +const { requireAuth } = require('../auth') + +const recoverLimiter = rateLimit({ + windowMs: 60000, + max: 3, + message: { error: 'too many recover requests' } +}) + module.exports = { init: (app) => { - app.get('/recover',(req,res) => { + app.get('/recover', recoverLimiter, requireAuth(), (req, res) => { + logr.warn('Manual recovery triggered from ' + req.ip) p2p.refresh(true) res.send({}) }) } -} \ No newline at end of file +} diff --git a/src/http/ssrf.js b/src/http/ssrf.js new file mode 100644 index 0000000..9797cf2 --- /dev/null +++ b/src/http/ssrf.js @@ -0,0 +1,171 @@ +const dns = require('dns/promises') +const net = require('net') + +const DNS_TIMEOUT = 5000 + +// Expands any IPv6 notation (including embedded IPv4 and zone ids) to the full +// 8-group form. Returns null when the input is not a valid IPv6 address. +function expandIPv6(ip) { + let s = String(ip).toLowerCase().split('%')[0].split('/')[0] + if (!s.includes(':')) + return null + + // Convert a trailing dotted-quad into the two hex groups it represents + const v4 = s.match(/(\d{1,3}(?:\.\d{1,3}){3})$/) + if (v4) { + const p = v4[1].split('.').map(Number) + if (p.some(x => !Number.isInteger(x) || x < 0 || x > 255)) return null + s = s.slice(0, s.length - v4[1].length) + + ((p[0] << 8) | p[1]).toString(16) + ':' + ((p[2] << 8) | p[3]).toString(16) + } + + const halves = s.split('::') + if (halves.length > 2) return null + + const head = halves[0] ? halves[0].split(':') : [] + const tail = halves.length === 2 && halves[1] ? halves[1].split(':') : [] + + const groups = halves.length === 1 + ? head + : head.concat(new Array(8 - head.length - tail.length).fill('0'), tail) + + if (groups.length !== 8) return null + const out = [] + for (const g of groups) { + if (!/^[0-9a-f]{1,4}$/.test(g)) return null + out.push(g.padStart(4, '0')) + } + return out +} + +function isPrivateIPv4(ip) { + const parts = ip.split('.').map(Number) + if (parts.length !== 4 || parts.some(p => !Number.isInteger(p) || p < 0 || p > 255)) + return true + const a = parts[0] + const b = parts[1] + if (a === 0) return true // 0.0.0.0/8 + if (a === 10) return true // 10.0.0.0/8 + if (a === 127) return true // 127.0.0.0/8 + if (a === 100 && b >= 64 && b <= 127) return true // 100.64.0.0/10 CGNAT + if (a === 169 && b === 254) return true // 169.254.0.0/16 link-local / cloud metadata + if (a === 172 && b >= 16 && b <= 31) return true // 172.16.0.0/12 + if (a === 192 && b === 0 && parts[2] === 0) return true + if (a === 192 && b === 168) return true // 192.168.0.0/16 + if (a === 198 && (b === 18 || b === 19)) return true // 198.18.0.0/15 benchmark + if (a >= 224) return true // multicast, reserved, broadcast + return false +} + +function isPrivateIPv6(ip) { + const g = expandIPv6(ip) + if (!g) return true + const n = i => parseInt(g[i], 16) + + // IPv4-mapped (::ffff:a.b.c.d, groups 0-4 == 0 and group 5 == 0xffff) and + // IPv4-compatible (::a.b.c.d, groups 0-5 == 0) forms carry a routable IPv4 + // address in the low 32 bits — these must go through the IPv4 checks or they + // become a trivial bypass of every private-range rule. + const zeroHigh = n(0) === 0 && n(1) === 0 && n(2) === 0 && n(3) === 0 + if (zeroHigh && n(4) === 0) { + if (n(5) !== 0 && n(5) !== 0xffff) return false // not a mapped/compat form + const embedded = [n(6) >> 8, n(6) & 0xff, n(7) >> 8, n(7) & 0xff].join('.') + return isPrivateIPv4(embedded) // :: and ::1 fall here as 0.0.0.0/0.0.0.1 + } + + if ((n(0) & 0xfe00) === 0xfc00) return true // fc00::/7 unique local + if ((n(0) & 0xffc0) === 0xfe80) return true // fe80::/10 link-local + if ((n(0) & 0xff00) === 0xff00) return true // ff00::/8 multicast + if (n(0) === 0x0064 && n(1) === 0xff9b) return true // 64:ff9b::/96 NAT64 + if (n(0) === 0x2001 && n(1) === 0x0db8) return true // 2001:db8::/32 documentation + if (n(0) === 0x2001 && (n(1) & 0xfff0) === 0x0000) return true // 2001::/32 Teredo + return false +} + +function isPrivateIP(ip) { + if (net.isIPv4(ip)) return isPrivateIPv4(ip) + if (net.isIPv6(ip)) return isPrivateIPv6(ip) + return true +} + +async function isPrivateURL(urlStr) { + try { + const parsed = new URL(urlStr) + if (!/^https?:$/.test(parsed.protocol)) return true + const host = parsed.hostname.replace(/^\[|\]$/g, '') + if (!host) return true + if (host === 'localhost' || host === '0.0.0.0' || host === '::') return true + + let ip + if (net.isIP(host)) + ip = host + else + try { + ip = (await dns.lookup(host, { family: 4 })).address + } catch { + return true + } + + if (!ip) return true + return isPrivateIP(ip) + } catch { + return true + } +} + +async function resolveAndPin(host) { + if (net.isIP(host)) return host + try { + const controller = new AbortController() + const timeout = setTimeout(() => controller.abort(), DNS_TIMEOUT) + try { + return (await dns.lookup(host, { family: 4, signal: controller.signal })).address + } finally { + clearTimeout(timeout) + } + } catch { + return null + } +} + +async function checkRebinding(host, pinnedIp) { + if (net.isIP(host)) return pinnedIp === host + try { + const controller = new AbortController() + const timeout = setTimeout(() => controller.abort(), DNS_TIMEOUT) + try { + return (await dns.lookup(host, { family: 4, signal: controller.signal })).address === pinnedIp + } finally { + clearTimeout(timeout) + } + } catch { + return false + } +} + +async function resolveSafeUrl(urlStr) { + const maxRedirects = 5 + let currentUrl = urlStr + for (let i = 0; i < maxRedirects; i++) { + if (await isPrivateURL(currentUrl)) + throw new Error('blocked private URL') + const parsed = new URL(currentUrl) + const pinnedIp = await resolveAndPin(parsed.hostname) + if (!pinnedIp) throw new Error('could not resolve host') + if (isPrivateIP(pinnedIp)) throw new Error('blocked private URL') + if (!(await checkRebinding(parsed.hostname, pinnedIp))) throw new Error('dns rebinding detected') + parsed.hostname = pinnedIp.includes(':') ? '[' + pinnedIp + ']' : pinnedIp + currentUrl = parsed.toString() + } + throw new Error('too many redirects') +} + +module.exports = { + isPrivateURL, + isPrivateIP, + expandIPv6, + resolveAndPin, + checkRebinding, + resolveSafeUrl, + DNS_TIMEOUT +} diff --git a/src/http/transact/index.js b/src/http/transact/index.js index 2fc3ec0..f5f2d89 100644 --- a/src/http/transact/index.js +++ b/src/http/transact/index.js @@ -1,3 +1,11 @@ +const rateLimit = require('express-rate-limit') + +const txLimiter = rateLimit({ + windowMs: 1000, + max: 5, + message: { error: 'too many requests' } +}) + module.exports = { init: (app) => { /** @@ -10,7 +18,7 @@ module.exports = { * @apiSuccess {Integer} _id The current block height * @apiError (Invalid Transaction Error) {String} error Error message of the invalid transaction */ - app.post('/transact', (req, res) => { + app.post('/transact', txLimiter, (req, res) => { let tx = req.body if (!tx) { res.sendStatus(500) diff --git a/src/http/transactWaitConfirm/index.js b/src/http/transactWaitConfirm/index.js index dc83dbf..16fc8a3 100644 --- a/src/http/transactWaitConfirm/index.js +++ b/src/http/transactWaitConfirm/index.js @@ -1,4 +1,10 @@ -const timeout_transact_async = 7500 +const rateLimit = require('express-rate-limit') + +const txLimiter = rateLimit({ + windowMs: 1000, + max: 5, + message: { error: 'too many requests' } +}) module.exports = { init: (app) => { @@ -8,8 +14,8 @@ module.exports = { * @apiGroup Broadcast * @apiDeprecated Use /transact instead */ - app.post('/transactWaitConfirm', (req, res) => { - res.redirect(307, "/transact") + app.post('/transactWaitConfirm', txLimiter, (req, res) => { + res.redirect(307, '/transact') }) } } diff --git a/src/http/trending/index.js b/src/http/trending/index.js index 359a74b..1515399 100644 --- a/src/http/trending/index.js +++ b/src/http/trending/index.js @@ -47,10 +47,16 @@ module.exports = { * * @apiSuccess {Object[]} contents List of ranked trending contents filtered */ + function isValidFilterValue(val) { + return /^[a-zA-Z0-9_\-.\u00C0-\u024F]+$/.test(val) + } + app.get('/trending/:filter', (req, res) => { let filterParam = req.params.filter let filter = filterParam.split(':') let filterBy = filter[1] + if (!filterBy) + return res.status(400).send({error: 'invalid filter'}) let filterAttrs = filterBy.split('&') let filterMap = {} @@ -80,7 +86,7 @@ module.exports = { filterMap['tags'] = [] filterMap['tags'].push('all') } else if (key === 'limit') - filterMap['limit'] = Number.MAX_SAFE_INTEGER + filterMap['limit'] = 50 } let tags = filterMap['tags'] @@ -93,14 +99,18 @@ module.exports = { else tags_in.push(tags[i]) + for (let v of tags_in.concat(tags_ex)) + if (v !== 'all' && !isValidFilterValue(v)) + return res.status(400).send({error: 'invalid filter value'}) + let limit = filterMap['limit'] - if(limit === -1 || isNaN(limit)) - limit = Number.MAX_SAFE_INTEGER + if (isNaN(limit) || limit < 1 || limit > 100) + limit = 50 let minTs = new Date().getTime() - rankings.types['trending'].halfLife*rankings.expireFactor - if (tags.includes('all')) + if (tags.includes('all')) db.collection('contents').find( { $and: [ @@ -110,7 +120,7 @@ module.exports = { { ts: {'$gt': minTs} } ] }, - {sort: {ts: -1}}).toArray(function(err, contents) { + {sort: {ts: -1}, limit: 5000}).toArray(function(err, contents) { for (let i = 0; i < contents.length; i++) { contents[i].score = 0 contents[i].ups = 0 @@ -127,6 +137,7 @@ module.exports = { contents = contents.sort(function(a,b) { return b.score - a.score }) + //rankings.contents['hot'] = contents res.send(contents.slice(0, limit)) }) else @@ -164,7 +175,7 @@ module.exports = { if (contents[i].votes[y].vt < 0) contents[i].downs += Math.abs(contents[i].votes[y].vt) } - contents[i].score = rankings.types['hot'].score(contents[i].ups, contents[i].downs, new Date(contents[i].ts)) + contents[i].score = rankings.types['trending'].score(contents[i].ups, contents[i].downs, new Date(contents[i].ts)) } contents = contents.sort(function(a,b) { return b.score - a.score diff --git a/src/http/tx/index.js b/src/http/tx/index.js index fafad5f..6633424 100644 --- a/src/http/tx/index.js +++ b/src/http/tx/index.js @@ -27,8 +27,10 @@ module.exports = { }) else db.collection('blocks').findOne({ 'txs.hash': req.params.txhash }, { projection: { txs: { $elemMatch: { hash: req.params.txhash}}}},(error,tx) => { - if (error) - res.status(500).send(error) + if (error) { + logr.error('transaction query failed', error) + res.status(500).send({error: 'query failed'}) + } else if (tx && tx.txs) { let result = tx.txs[0] result.includedInBlock = tx._id diff --git a/src/http/version/index.js b/src/http/version/index.js new file mode 100644 index 0000000..f476439 --- /dev/null +++ b/src/http/version/index.js @@ -0,0 +1,16 @@ +const pkg = require('../../../package.json') + +module.exports = { + init: (app) => { + /** + * @api {get} /version Node Version + * @apiName version + * @apiGroup Blockchain + * + * @apiSuccess {String} version The avalon package version (e.g. "2.0.0") + */ + app.get('/version', (req, res) => { + res.send({ version: pkg.version }) + }) + } +} diff --git a/src/http/votes/index.js b/src/http/votes/index.js index c10de7b..3a0d414 100644 --- a/src/http/votes/index.js +++ b/src/http/votes/index.js @@ -29,7 +29,7 @@ module.exports = { query['$and'].push({ ts: { $lt: lastTs } }) db.collection('contents').find(query, { sort: { ts: -1 }, limit: 50 }).toArray(function (err, contents) { - if (err) throw err + if (err) { logr.error('Votes query failed', err); return res.status(500).send({error: 'query failed'}) } let votes = [] for (let i = 0; i < contents.length; i++) for (let y = 0; y < contents[i].votes.length; y++) @@ -61,7 +61,7 @@ module.exports = { query['$and'].push({ ts: { $lt: lastTs } }) db.collection('contents').find(query, { sort: { ts: -1 }, limit: 50 }).toArray(function (err, contents) { - if (err) throw err + if (err) { logr.error('Votes query failed', err); return res.status(500).send({error: 'query failed'}) } let votes = [] for (let i = 0; i < contents.length; i++) for (let y = 0; y < contents[i].votes.length; y++) @@ -114,7 +114,7 @@ module.exports = { query['$and'].push({ ts: { $lt: lastTs } }) db.collection('contents').find(query, { sort: { ts: -1 }, limit: 50 }).toArray(function (err, contents) { - if (err) throw err + if (err) { logr.error('Votes query failed', err); return res.status(500).send({error: 'query failed'}) } let votes = [] for (let i = 0; i < contents.length; i++) for (let y = 0; y < contents[i].votes.length; y++) @@ -168,7 +168,7 @@ module.exports = { if (lastTs > 0) query['$and'].push({ ts: { $lt: lastTs } }) db.collection('contents').find(query, { sort: { ts: -1 }, limit: 50 }).toArray(function (err, contents) { - if (err) throw err + if (err) { logr.error('Votes query failed', err); return res.status(500).send({error: 'query failed'}) } let votes = [] for (let i = 0; i < contents.length; i++) for (let y = 0; y < contents[i].votes.length; y++) @@ -221,7 +221,7 @@ module.exports = { if (lastTs > 0) query['$and'].push({ ts: { $lt: lastTs } }) db.collection('contents').find(query, { sort: { ts: -1 }, limit: 50 }).toArray(function (err, contents) { - if (err) throw err + if (err) { logr.error('Votes query failed', err); return res.status(500).send({error: 'query failed'}) } let votes = [] for (let i = 0; i < contents.length; i++) for (let y = 0; y < contents[i].votes.length; y++) diff --git a/src/http/youtube/index.js b/src/http/youtube/index.js index e13250a..c799555 100644 --- a/src/http/youtube/index.js +++ b/src/http/youtube/index.js @@ -1,11 +1,12 @@ const YT = require('simple-youtube-api') -const yt_key = process.env.YT_API_KEY || 'NO_KEY' -const yt = new YT(yt_key) module.exports = { init: (app) => { - // 3rd party video embed data - // get youtube info + if (!process.env.YT_API_KEY) { + app.get('/youtube/:videoId', (req, res) => res.status(501).send({error: 'youtube API not configured'})) + return + } + const yt = new YT(process.env.YT_API_KEY) app.get('/youtube/:videoId', (req, res) => { if (!req.params.videoId) { res.sendStatus(500) @@ -20,4 +21,4 @@ module.exports = { }) }) } -} +} \ No newline at end of file diff --git a/src/leaderStats.js b/src/leaderStats.js index 7f8b41d..a23e8db 100644 --- a/src/leaderStats.js +++ b/src/leaderStats.js @@ -89,13 +89,14 @@ let indexer = { getWriteOps: () => { if (process.env.LEADER_STATS !== '1') return [] let ops = [] - for (let acc in indexer.updates.leaders) { - let updatedLeader = indexer.updates.leaders[acc] + const updates = indexer.updates.leaders.slice() + indexer.updates.leaders = [] + for (let a = 0; a < updates.length; a++) { + let updatedLeader = updates[a] ops.push((cb) => db.collection('leaders').updateOne({_id: updatedLeader },{ $set: indexer.leaders[updatedLeader] },{ upsert: true },() => cb(null,true))) } - indexer.updates.leaders = [] return ops }, loadIndex: () => { @@ -103,7 +104,7 @@ let indexer = { if (process.env.LEADER_STATS !== '1') return rs() db.collection('leaders').find({},{}).toArray((e,leaders) => { if (e) return rj(e) - if (leaders) for (let i in leaders) { + if (leaders) for (let i = 0; i < leaders.length; i++) { indexer.leaders[leaders[i]._id] = leaders[i] delete indexer.leaders[leaders[i]._id]._id } diff --git a/src/logAppender.js b/src/logAppender.js new file mode 100644 index 0000000..5cae4fc --- /dev/null +++ b/src/logAppender.js @@ -0,0 +1,14 @@ +const logBuffer = require('./logBuffer') + +function appender(config, layouts) { + const layout = layouts.basicLayout + + return function(logEvent) { + const formatted = layout(logEvent, config) + logBuffer.append(formatted, logEvent.level.levelStr) + } +} + +appender.configure = appender + +module.exports = appender diff --git a/src/logBuffer.js b/src/logBuffer.js new file mode 100644 index 0000000..d5a19ab --- /dev/null +++ b/src/logBuffer.js @@ -0,0 +1,97 @@ +const EventEmitter = require('events') +const MAX_LOGS = 1000 +const MAX_MESSAGE_LENGTH = 10000 + +const SECRET_ENV_KEYS = [ + 'NODE_OWNER_PRIV', + 'YT_API_KEY', + 'NODE_OWNER', + 'NODE_OWNER_PUB', + 'DB_URL', + 'DB_NAME', + 'ADMIN_TOKEN', + 'LOG_ADMIN_TOKEN', + 'MINE_TOKEN', + 'DEBUG_TOKEN', + 'RECOVER_TOKEN' +] + +const IPV4 = /\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b/g + +const IPV6_BASIC = /(?:[a-fA-F0-9]{1,4}:){7}[a-fA-F0-9]{1,4}|(?:[a-fA-F0-9]{1,4}:){1,7}:|(?:[a-fA-F0-9]{1,4}:){1,6}:[a-fA-F0-9]{1,4}|(?:[a-fA-F0-9]{1,4}:){1,5}(?::[a-fA-F0-9]{1,4}){1,2}|(?:[a-fA-F0-9]{1,4}:){1,4}(?::[a-fA-F0-9]{1,4}){1,3}|(?:[a-fA-F0-9]{1,4}:){1,3}(?::[a-fA-F0-9]{1,4}){1,4}|(?:[a-fA-F0-9]{1,4}:){1,2}(?::[a-fA-F0-9]{1,4}){1,5}|[a-fA-F0-9]{1,4}:(?:(?::[a-fA-F0-9]{1,4}){1,6})|:(?:(?::[a-fA-F0-9]{1,4}){1,7}|:)/g + +const MONGO_CREDS = /(mongodb(?:\+srv)?:\/\/)([^@]+@)/g + +const STACK_LINE = /^\s+at\s.*$/gm + +const SECRET_PATTERNS = SECRET_ENV_KEYS.map(k => new RegExp(`${k}=[^\\s&"']+`, 'g')) + +function sanitizeMessage(msg) { + if (typeof msg !== 'string') return String(msg) + if (msg.length > MAX_MESSAGE_LENGTH) msg = msg.slice(0, MAX_MESSAGE_LENGTH) + '...[truncated]' + msg = msg.replace(MONGO_CREDS, '$1[REDACTED]@') + msg = msg.replace(IPV4, '[IP]') + msg = msg.replace(IPV6_BASIC, '[IP]') + for (const re of SECRET_PATTERNS) msg = msg.replace(re, (m) => m.replace(/=.*/, '=[REDACTED]')) + msg = msg.replace(STACK_LINE, ' at [stack]') + return msg +} + +function sanitizeMessageFull(msg) { + if (typeof msg !== 'string') return String(msg) + if (msg.length > MAX_MESSAGE_LENGTH) msg = msg.slice(0, MAX_MESSAGE_LENGTH) + '...[truncated]' + msg = msg.replace(MONGO_CREDS, '$1[REDACTED]@') + msg = msg.replace(IPV4, '[IP]') + msg = msg.replace(IPV6_BASIC, '[IP]') + for (const re of SECRET_PATTERNS) msg = msg.replace(re, (m) => m.replace(/=.*/, '=[REDACTED]')) + msg = msg.replace(STACK_LINE, ' at [stack]') + return msg +} + +let buffer = [] + +const emitter = new EventEmitter() +emitter.setMaxListeners(200) + +module.exports = { + append(rawMessage, level) { + const ts = Date.now() + const entry = { + ts, + level: level || 'INFO', + message: sanitizeMessage(rawMessage), + _raw: typeof rawMessage === 'string' && process.env.LOG_FULL === '1' && process.env.LOG_ADMIN_TOKEN ? sanitizeMessageFull(rawMessage) : undefined + } + buffer.push(entry) + if (buffer.length > MAX_LOGS) buffer.shift() + + try { emitter.emit('log', entry) } catch (e) { /* ignore */ } + }, + + getLogs({ level, search, full } = {}) { + let result = buffer + if (level) { + const levels = Array.isArray(level) ? level : [level] + result = result.filter(e => levels.includes(e.level)) + } + if (search) { + const q = search.toLowerCase() + result = result.filter(e => e.message.toLowerCase().includes(q)) + } + if (!full) + result = result.map(e => { + const rest = { ...e } + delete rest._raw + return rest + }) + + return result + }, + + emitter, + + sanitizeMessage, + sanitizeMessageFull, + + clear() { buffer = [] } +} diff --git a/src/logger.js b/src/logger.js index 8f248d4..c1cf734 100644 --- a/src/logger.js +++ b/src/logger.js @@ -17,11 +17,12 @@ log4js.configure({ maxLogSize: 10485760, backups: 3, compress: true - } + }, + buffer: { type: './logAppender' } }, - categories: { - default: { - appenders: ['out', 'file'], + categories: { + default: { + appenders: ['out', 'file', 'buffer'], level: process.env.LOG_LEVEL || 'info' } } diff --git a/src/main.js b/src/main.js index 5bda037..1793680 100644 --- a/src/main.js +++ b/src/main.js @@ -18,10 +18,9 @@ const mongo = require('./mongo') const http = require('./http') // verify node version -const allowNodeV = [18, 20, 22] const currentNodeV = parseInt(process.versions.node.split('.')[0]) -if (allowNodeV.indexOf(currentNodeV) === -1) { - logr.fatal('Wrong NodeJS version. Allowed versions: v'+allowNodeV.join(', v')) +if (currentNodeV < 24) { + logr.fatal('Wrong NodeJS version. Allowed versions: >= v24') process.exit(1) } else logr.info('Correctly using NodeJS v'+process.versions.node) diff --git a/src/mongo.js b/src/mongo.js index 3fc29c0..ecda6ad 100644 --- a/src/mongo.js +++ b/src/mongo.js @@ -12,7 +12,7 @@ let mongo = { useNewUrlParser: true, useUnifiedTopology: true }, async function(err, client) { - if (err) throw err + if (err) { logr.fatal('MongoDB connection failed: ' + err.message); process.exit(1) } this.db = client.db(db_name) try { await this.db.executeDbAdminCommand({ @@ -20,7 +20,7 @@ let mongo = { internalQueryExecMaxBlockingSortBytes: 335544320 }) } catch (e) {} - logr.info('Connected to '+db_url+'/'+this.db.databaseName) + logr.info('Connected to '+db_url.replace(/\/\/[^@/]*@/, '//[REDACTED]@')+'/'+this.db.databaseName) let state = await this.db.collection('state').findOne({_id: 0}) @@ -137,7 +137,7 @@ let mongo = { }, fillInMemoryBlocks: (cb,headBlock) => { let query = {} - if (headBlock) query._id = {$lt: headBlock} + if (headBlock && Number.isInteger(headBlock) && headBlock > 0) query._id = {$lt: headBlock} db.collection('blocks').find(query, { sort: {_id: -1}, limit: config.ecoBlocksIncreasesSoon ? config.ecoBlocksIncreasesSoon : config.ecoBlocks diff --git a/src/notifications.js b/src/notifications.js index 3a1cdb0..89ca979 100644 --- a/src/notifications.js +++ b/src/notifications.js @@ -28,7 +28,7 @@ notifications = { ts: ts } db.collection('notifications').insertOne(notif, function(err) { - if (err) throw err + if (err) logr.error('Notification insert failed', err) }) break @@ -39,7 +39,7 @@ notifications = { ts: ts } db.collection('notifications').insertOne(notif, function(err) { - if (err) throw err + if (err) logr.error('Notification transfer insert failed', err) }) break @@ -49,14 +49,15 @@ notifications = { /** Find replies */ if (tx.data.pa && tx.data.pa !== tx.sender) { + const txClone = JSON.parse(JSON.stringify(tx)) notif = { u: tx.data.pa, - tx: tx, + tx: txClone, ts: ts } - notif.tx.data.json = {} + delete notif.tx.data.json db.collection('notifications').insertOne(notif, function(err) { - if (err) throw err + if (err) logr.error('Notification insert failed', err) }) } @@ -69,14 +70,19 @@ notifications = { for (let y = 0; y < words[i].length; y++) if (config.allowedUsernameChars.indexOf(words[i][y]) === -1) { if (y > 0) { - notif = { - u: words[i].substring(0,y), - tx: tx, - ts: ts - } - delete notif.tx.data.json - db.collection('notifications').insertOne(notif, function(err) { - if (err) throw err + let candidate = words[i].substring(0,y) + cache.findOne('accounts', {name: candidate}, function(err, account) { + if (!err && account) { + let mNotif = { + u: candidate, + tx: tx, + ts: ts + } + delete mNotif.tx.data.json + db.collection('notifications').insertOne(mNotif, function(err2) { + if (err2) logr.error('Notification mention insert failed', err2) + }) + } }) mentions++ } @@ -95,7 +101,7 @@ notifications = { ts: ts } db.collection('notifications').insertOne(notif, function(err) { - if (err) throw err + if (err) logr.error('Notification vote insert failed', err) }) break diff --git a/src/p2p.js b/src/p2p.js index b0902a4..3c90235 100644 --- a/src/p2p.js +++ b/src/p2p.js @@ -6,6 +6,10 @@ const keep_alive_interval = 2500 const max_blocks_buffer = 100 const max_peers = process.env.MAX_PEERS || 15 const max_recover_attempts = 25 +// per-socket throttle for the message types that trigger expensive local work +// (block revalidation, disk reads, consensus rounds) +const msg_rate_window = 1000 +const msg_rate_max = 40 const history_interval = 10000 const keep_history_for = 20000 const p2p_port = process.env.P2P_PORT || default_port @@ -13,6 +17,16 @@ const p2p_host = process.env.P2P_HOST || '::' const WebSocket = require('ws') const dns = require('dns').promises const net = require('net') + +// Fisher-Yates shuffle using crypto.randomInt (cryptographically secure) +function secureShuffle(arr) { + for (let i = arr.length - 1; i > 0; i--) { + const j = crypto.randomInt(0, i + 1); + [arr[i], arr[j]] = [arr[j], arr[i]] + } + return arr +} +const crypto = require('crypto') const { randomBytes } = require('crypto') const secp256k1 = require('secp256k1') const bs58 = require('base-x')(config.b58Alphabet) @@ -20,6 +34,15 @@ const blocks = require('./blocks') const dao = require('./dao') const daoMaster = require('./daoMaster') +const ff_amplify_seen = {} + +setInterval(() => { + const now = Date.now() + for (const k in ff_amplify_seen) + if (now - ff_amplify_seen[k] > 120000) + delete ff_amplify_seen[k] +}, 60000) + const MessageType = { QUERY_NODE_STATUS: 0, NODE_STATUS: 1, @@ -27,11 +50,15 @@ const MessageType = { BLOCK: 3, NEW_BLOCK: 4, NEW_TX: 5, - BLOCK_CONF_ROUND: 6 + BLOCK_CONF_ROUND: 6, + FORCE_FINALIZE: 7 } let p2p = { sockets: [], + bannedPeers: {}, + peerFailures: {}, + blockSenders: {}, recoveringBlocks: [], recoveredBlocks: [], recovering: false, @@ -39,7 +66,7 @@ let p2p = { nodeId: null, init: () => { p2p.generateNodeId() - let server = new WebSocket.Server({host:p2p_host, port: p2p_port}) + let server = new WebSocket.Server({host:p2p_host, port: p2p_port, maxPayload: 10 * 1024 * 1024}) server.on('connection', ws => p2p.handshake(ws)) logr.info('Listening websocket p2p port on: ' + p2p_port) logr.info('Version:',version) @@ -95,9 +122,9 @@ let p2p = { // ensure all peers explicitly listed in PEERS are connected when online let peers = process.env.PEERS ? process.env.PEERS.split(',') : [] let toConnect = [] - for (let p in peers) { + for (let p = 0; p < peers.length; p++) { let connected = false - let colonSplit = peers[p].replace('ws://','').split(':') + let colonSplit = peers[p].replace(/^wss?:\/\//,'').split(':') let port = parseInt(colonSplit.pop()) let address = colonSplit.join(':').replace('[','').replace(']','') if (!net.isIP(address)) @@ -107,7 +134,7 @@ let p2p = { logr.debug('dns lookup failed for '+address) continue } - for (let s in p2p.sockets) + for (let s = 0; s < p2p.sockets.length; s++) if (p2p.sockets[s]._socket.remoteAddress.replace('::ffff:','') === address && p2p.sockets[s]._socket.remotePort === port) { connected = true break @@ -136,6 +163,14 @@ let p2p = { logr.warn('Incoming handshake refused because already peered enough '+p2p.sockets.length+'/'+max_peers) ws.close(); return } + // refuse connection from banned peers + let remoteIp = ws._socket.remoteAddress + if (remoteIp.indexOf('::ffff:') > -1) + remoteIp = remoteIp.replace('::ffff:', '') + if (p2p.isBanned(remoteIp)) { + logr.warn('Refused handshake from banned peer ' + remoteIp) + ws.close(); return + } // close connection if we already have this peer ip in our connected sockets for (let i = 0; i < p2p.sockets.length; i++) if (p2p.sockets[i]._socket.remoteAddress === ws._socket.remoteAddress @@ -166,6 +201,26 @@ let p2p = { }) }, messageHandler: (ws) => { + // Throttle cost-driving message types per socket. NODE_STATUS messages + // (t 0/1) are excluded: they only carry the handshake and are cheap. + ws.msgWindow = Date.now() + ws.msgCount = 0 + ws.isRateLimited = (t) => { + if (t !== MessageType.QUERY_BLOCK && t !== MessageType.NEW_BLOCK + && t !== MessageType.BLOCK_CONF_ROUND && t !== MessageType.FORCE_FINALIZE) + return false + const now = Date.now() + if (now - ws.msgWindow >= msg_rate_window) { + ws.msgWindow = now + ws.msgCount = 0 + } + ws.msgCount++ + if (ws.msgCount > msg_rate_max) { + logr.warn('P2P message rate limit exceeded, disconnecting peer') + return true + } + return false + } ws.on('message', (data) => { let message try { @@ -175,14 +230,15 @@ let p2p = { } if (!message || typeof message.t === 'undefined') return if (!message.d) return + if (ws.isRateLimited(message.t)) return ws.close() // logr.debug('P2P-IN '+message.t) switch (message.t) { case MessageType.QUERY_NODE_STATUS: // a peer is requesting our node status if (typeof message.d !== 'object' - && typeof message.d.nodeId !== 'string' - && typeof message.d.random !== 'string') + || typeof message.d.nodeId !== 'string' + || typeof message.d.random !== 'string') return let wsNodeId = message.d.nodeId if (wsNodeId === p2p.nodeId.pub) { @@ -212,57 +268,59 @@ let p2p = { case MessageType.NODE_STATUS: // we received a peer node status - if (typeof message.d.sign === 'string') { - let nodeId = p2p.sockets[p2p.sockets.indexOf(ws)].node_status.nodeId - if (!message.d.nodeId || message.d.nodeId !== nodeId) - return - let challengeHash = p2p.sockets[p2p.sockets.indexOf(ws)].challengeHash - if (!challengeHash) + if (typeof message.d !== 'object' || typeof message.d.sign !== 'string') break + let nodeId = p2p.sockets[p2p.sockets.indexOf(ws)].node_status.nodeId + if (!message.d.nodeId || message.d.nodeId !== nodeId) + return + let challengeHash = p2p.sockets[p2p.sockets.indexOf(ws)].challengeHash + if (!challengeHash) + return + if (message.d.origin_block !== config.originHash) { + logr.debug('Different chain id, disconnecting') + return ws.close() + } + try { + let isValidSignature = secp256k1.ecdsaVerify( + bs58.decode(message.d.sign), + Buffer.from(challengeHash, 'hex'), + bs58.decode(nodeId)) + if (!isValidSignature) { + logr.warn('Wrong NODE_STATUS signature, disconnecting') + ws.close() return - if (message.d.origin_block !== config.originHash) { - logr.debug('Different chain id, disconnecting') - return ws.close() } - try { - let isValidSignature = secp256k1.ecdsaVerify( - bs58.decode(message.d.sign), - Buffer.from(challengeHash, 'hex'), - bs58.decode(nodeId)) - if (!isValidSignature) { - logr.warn('Wrong NODE_STATUS signature, disconnecting') - ws.close() + + for (let i = 0; i < p2p.sockets.length; i++) + if (i !== p2p.sockets.indexOf(ws) + && p2p.sockets[i].node_status + && p2p.sockets[i].node_status.nodeId === nodeId) { + logr.debug('Peer disconnected because duplicate connections') + p2p.sockets[i].close() } - - for (let i = 0; i < p2p.sockets.length; i++) - if (i !== p2p.sockets.indexOf(ws) - && p2p.sockets[i].node_status - && p2p.sockets[i].node_status.nodeId === nodeId) { - logr.debug('Peer disconnected because duplicate connections') - p2p.sockets[i].close() - } - - clearInterval(p2p.sockets[p2p.sockets.indexOf(ws)].pendingDisconnect) - delete message.d.sign - p2p.sockets[p2p.sockets.indexOf(ws)].node_status = message.d - } catch (error) { - logr.error('Error during NODE_STATUS verification', error) - } + + clearTimeout(p2p.sockets[p2p.sockets.indexOf(ws)].pendingDisconnect) + delete message.d.sign + p2p.sockets[p2p.sockets.indexOf(ws)].node_status = message.d + } catch (error) { + logr.error('Error during NODE_STATUS verification', error) } - + break case MessageType.QUERY_BLOCK: // a peer wants to see the data in one of our stored blocks + const blockId = parseInt(message.d, 10) + if (isNaN(blockId) || blockId < 0) break if (blocks.isOpen) { let block = {} try { - block = blocks.read(message.d) + block = blocks.read(blockId) } catch (e) { break } p2p.sendJSON(ws, {t:MessageType.BLOCK, d:block}) } else - db.collection('blocks').findOne({_id: message.d}, function(err, block) { + db.collection('blocks').findOne({_id: blockId}, function(err, block) { if (err) throw err if (block) @@ -300,6 +358,10 @@ let p2p = { p2p.sockets[p2p.sockets.indexOf(ws)].node_status.head_block_hash = block.hash p2p.sockets[p2p.sockets.indexOf(ws)].node_status.previous_block_hash = block.phash + // track which peer sent this block for failure banning + if (block.hash) + p2p.blockSenders[block.hash] = { ws, ts: Date.now() } + if (p2p.recovering) return consensus.round(0, block) break @@ -332,8 +394,8 @@ let p2p = { // it should come from one of the elected leaders, so let's verify signature if (p2p.recovering) return if (!message.s || !message.s.s || !message.s.n) return - if (!message.d || !message.d.ts || - typeof message.d.ts != 'number' || + if (!message.d || !Number.isFinite(message.d.ts) || + !Number.isInteger(message.d.ts) || message.d.ts <= 0 || message.d.ts + 2*config.blockTime < new Date().getTime() || message.d.ts - 2*config.blockTime > new Date().getTime()) return @@ -345,16 +407,13 @@ let p2p = { p2p.sockets[p2p.sockets.indexOf(ws)].sentUs.push([message.s.s,new Date().getTime()]) } - for (let i = 0; i < consensus.processed.length; i++) { - if (consensus.processed[i][1] + 2*config.blockTime < new Date().getTime()) { - consensus.processed.splice(i, 1) - i-- - continue - } + const now = Date.now() + const blockTime2x = 2 * config.blockTime + consensus.processed = consensus.processed.filter(p => p[1] + blockTime2x >= now) + for (let i = 0; i < consensus.processed.length; i++) if (consensus.processed[i][0].s.s === message.s.s) return - } - consensus.processed.push([message, new Date().getTime()]) + consensus.processed.push([message, now]) consensus.verifySignature(message, function(isValid) { if (!isValid && !p2p.recovering) { @@ -371,7 +430,10 @@ let p2p = { // logr.trace('Ignored BLOCK_CONF_ROUND') } else if (validationStep === 0) { // block is being validated, we queue the message - consensus.queue.push(message) + if (consensus.queue.length >= consensus.maxQueueSize) + logr.warn('Consensus queue at capacity, dropping message') + else + consensus.queue.push(message) logr.debug('Added to queue') } else // process the message inside the consensus @@ -379,12 +441,35 @@ let p2p = { }) }) break + + case MessageType.FORCE_FINALIZE: + if (!message.s || !message.s.s || !message.s.n) break + // Verify signature before any dedup to prevent unauthenticated poison + consensus.verifySignature(message, function(isValid) { + if (!isValid) { + logr.warn('Received wrong FF signature from ' + message.s.n) + return + } + // Dedup by sender+signature to prevent broadcast amplification + const ffKey = message.s.n + '_' + message.s.s + const now = Date.now() + if (ff_amplify_seen[ffKey] && now - ff_amplify_seen[ffKey] < 120000) return + ff_amplify_seen[ffKey] = now + // Expire stale dedup entries + for (const kk in ff_amplify_seen) + if (Date.now() - ff_amplify_seen[kk] > 120000) + delete ff_amplify_seen[kk] + p2p.broadcastNotSent(message) + consensus.handleForceFinalizeProposal(message) + }) + break } }) }, recover: () => { if (!p2p.sockets || p2p.sockets.length === 0) return - if (Object.keys(p2p.recoveredBlocks).length + p2p.recoveringBlocks.length > max_blocks_buffer) return + if (p2p._recoverTicking) return + if (Object.keys(p2p.recoveredBlocks || {}).length + (p2p.recoveringBlocks || []).length > max_blocks_buffer) return if (!p2p.recovering) p2p.recovering = chain.getLatestBlock()._id let peersAhead = [] @@ -399,13 +484,27 @@ let p2p = { return } - let champion = peersAhead[Math.floor(Math.random()*peersAhead.length)] + secureShuffle(peersAhead) + let champions = peersAhead.slice(0, Math.min(3, peersAhead.length)) + let champion = champions[0] if (p2p.recovering+1 <= champion.node_status.head_block) { - p2p.recovering++ - p2p.sendJSON(champion, {t: MessageType.QUERY_BLOCK, d:p2p.recovering}) - p2p.recoveringBlocks.push(p2p.recovering) - logr.debug('query block #'+p2p.recovering+' -- head block: '+champion.node_status.head_block) - if (p2p.recovering%2) p2p.recover() + p2p._recoverTicking = true + const next = p2p.recovering + 1 + p2p.recovering = next + // Space requests to avoid tripping the per-socket rate limit + champions.forEach((ch, idx) => { + setTimeout(() => { + try { p2p.sendJSON(ch, {t: MessageType.QUERY_BLOCK, d: next}) } catch(e){} + }, idx * 25) + }) + if (!p2p.recoveringBlocks) p2p.recoveringBlocks = [] + if (!p2p.recoveredBlocks) p2p.recoveredBlocks = {} + p2p.recoveringBlocks.push(next) + logr.debug('query block #'+next+' -- head block: '+champion.node_status.head_block) + setTimeout(() => { + p2p._recoverTicking = false + p2p.recover() + }, 80) } }, refresh: (force = false) => { @@ -425,8 +524,50 @@ let p2p = { ws.on('error', () => p2p.closeConnection(ws)) }, closeConnection: (ws) => { - p2p.sockets.splice(p2p.sockets.indexOf(ws), 1) + const idx = p2p.sockets.indexOf(ws) + if (idx !== -1) + p2p.sockets.splice(idx, 1) logr.debug('a peer disconnected, '+p2p.sockets.length+' peers left') + // If we were catching up and lost peers, reset recovery state so + // p2p.refresh() can retry automatically instead of getting stuck. + if (p2p.recovering) { + if (p2p.sockets.length === 0) { + logr.debug('Lost all peers while recovering, resetting recovery state') + p2p.recovering = false + p2p.recoveringBlocks = [] + p2p.recoveredBlocks = {} + } + } + }, + recordBlockFailure: (blockHash) => { + const entry = p2p.blockSenders[blockHash] + delete p2p.blockSenders[blockHash] + if (!entry || !entry.ws || !entry.ws._socket) return + let ws = entry.ws + let ip = ws._socket.remoteAddress + if (ip.indexOf('::ffff:') > -1) + ip = ip.replace('::ffff:', '') + // cap peerFailures to prevent memory leak from IP cycling + if (Object.keys(p2p.peerFailures).length >= 1000) + return + if (!p2p.peerFailures[ip]) + p2p.peerFailures[ip] = 0 + p2p.peerFailures[ip]++ + if (p2p.peerFailures[ip] >= 5) { + const banSeconds = 300 // 5 minutes + logr.warn('Banning peer ' + ip + ' for ' + banSeconds + 's (' + p2p.peerFailures[ip] + ' failures)') + p2p.bannedPeers[ip] = Date.now() + banSeconds * 1000 + delete p2p.peerFailures[ip] + ws.close() + } + }, + isBanned: (ip) => { + if (!p2p.bannedPeers[ip]) return false + if (Date.now() > p2p.bannedPeers[ip]) { + delete p2p.bannedPeers[ip] + return false + } + return true }, sendJSON: (ws, d) => { try { @@ -465,8 +606,11 @@ let p2p = { p2p.recoveredBlocks = [] p2p.recoveringBlocks = [] p2p.recoverAttempt++ - if (p2p.recoverAttempt > max_recover_attempts) + if (p2p.recoverAttempt > max_recover_attempts) { logr.error('Error Replay', newBlock._id) + p2p.recovering = false + p2p.recoverAttempt = 0 + } else { logr.warn('Recover attempt #'+p2p.recoverAttempt+' for block '+newBlock._id) p2p.recovering = chain.getLatestBlock()._id @@ -495,6 +639,20 @@ let p2p = { y-- } } + // clean stale blockSenders entries (older than 2 minutes) + const now = Date.now() + Object.keys(p2p.blockSenders).forEach(hash => { + if (now - p2p.blockSenders[hash].ts > 120000) + delete p2p.blockSenders[hash] + }) + // cap total size to bound memory under hostile block bursts + const maxBlockSenders = 10000 + const keys = Object.keys(p2p.blockSenders) + if (keys.length > maxBlockSenders) { + const sorted = keys.sort((a,b) => p2p.blockSenders[a].ts - p2p.blockSenders[b].ts) + for (let i = 0; i < sorted.length - maxBlockSenders; i++) + delete p2p.blockSenders[sorted[i]] + } } } diff --git a/src/processingQueue.js b/src/processingQueue.js index e6c028f..f819a47 100644 --- a/src/processingQueue.js +++ b/src/processingQueue.js @@ -14,12 +14,13 @@ class ProcessingQueue { execute() { let first = this.queue.shift() - first(() => { + let cb = () => { if (this.queue.length > 0) this.execute() else this.processing = false - }) + } + try { first(cb) } catch(e) { logr.error('queue error', e); cb() } } } diff --git a/src/rankings.js b/src/rankings.js index 5e1ff6c..680f6d0 100644 --- a/src/rankings.js +++ b/src/rankings.js @@ -4,6 +4,7 @@ const hotHalfTime = 43200 // 12 hours const trendingHalfTime = 302400 // 3.5 days const expireFactor = 5000 // disappears after 5 half times const isEnabled = process.env.RANKINGS || false +const MAX_RANKINGS = 5000 let rankings = { expireFactor: expireFactor, @@ -33,7 +34,8 @@ let rankings = { if (!isEnabled || chain.getLatestBlock()._id < chain.restoredBlocks) return for (const key in rankings.types) { let minTs = new Date().getTime() - rankings.types[key].halfLife*expireFactor - db.collection('contents').find({pa: null, ts: {'$gt': minTs}}, {sort: {ts: -1}}).toArray(function(err, contents) { + db.collection('contents').find({pa: null, ts: {'$gt': minTs}}, {sort: {ts: -1}, limit: MAX_RANKINGS}).toArray(function(err, contents) { + if (err) { logr.error('Rankings generate failed', err); return } for (let i = 0; i < contents.length; i++) { contents[i].score = 0 contents[i].ups = 0 @@ -69,7 +71,7 @@ let rankings = { break } - if (alreadyAdded) return + if (alreadyAdded) continue content._id = content.author+'/'+content.link content.score = 0 @@ -81,6 +83,8 @@ let rankings = { if (content.votes[0] && content.votes[0].vt < 0) content.downs += Math.abs(content.votes[0].vt) rankings.contents[key].push(JSON.parse(JSON.stringify(content))) + if (rankings.contents[key].length > MAX_RANKINGS) + rankings.contents[key].splice(MAX_RANKINGS) } }, update: function(author, link, vote, dist) { @@ -89,7 +93,7 @@ let rankings = { for (let i = 0; i < rankings.contents[key].length; i++) if (rankings.contents[key][i].author === author && rankings.contents[key][i].link === link) { let ts = rankings.contents[key][i].ts - if (ts < new Date().getTime() - rankings.types[key].halfTime*expireFactor) + if (ts < new Date().getTime() - rankings.types[key].halfLife*expireFactor) return for (let y = 0; y < rankings.contents[key][i].votes.length; y++) diff --git a/src/transaction.js b/src/transaction.js index 3dd39a9..f3fcc95 100644 --- a/src/transaction.js +++ b/src/transaction.js @@ -1,5 +1,5 @@ const GrowInt = require('growint') -const CryptoJS = require('crypto-js') +const crypto = require('crypto') const { EventEmitter } = require('events') const cloneDeep = require('clone-deep') const bson = require('bson') @@ -16,20 +16,60 @@ const skiphash = { let transaction = { pool: [], // the pool holds temporary txs that havent been published on chain yet eventConfirmation: new EventEmitter(), - addToPool: (txs) => { - if (transaction.isPoolFull()) + poolQueue: [], + poolLock: false, + maxPoolQueue: 1000, + processPoolQueue: () => { + if (transaction.poolQueue.length === 0 || transaction.poolLock) return + const item = transaction.poolQueue.shift() + if (!item) return + transaction.addToPool(item, true) + }, + addToPool: (txs, fromQueue) => { + if (!fromQueue && transaction.poolLock) { + if (transaction.poolQueue.length >= transaction.maxPoolQueue) { + transaction.poolQueue.shift() + logr.warn('Pool queue overflow, evicting oldest') + } + transaction.poolQueue.push(txs) return - - for (let y = 0; y < txs.length; y++) { - let exists = false - for (let i = 0; i < transaction.pool.length; i++) - if (transaction.pool[i].hash === txs[y].hash) - exists = true - - if (!exists) - transaction.pool.push(txs[y]) } - + if (transaction.isPoolFull()) { + transaction.poolQueue = [] + return + } + transaction.poolLock = true + try { + for (let y = 0; y < txs.length; y++) { + if (transaction.isPoolFull()) break + let exists = false + for (let i = 0; i < transaction.pool.length; i++) + if (transaction.pool[i].hash === txs[y].hash) + exists = true + + if (!exists) + transaction.pool.push(txs[y]) + } + // drain queue while we hold the lock + while (transaction.poolQueue.length > 0) { + if (transaction.isPoolFull()) { + transaction.poolQueue = [] + break + } + const qItem = transaction.poolQueue.shift() + for (let y = 0; y < qItem.length; y++) { + if (transaction.isPoolFull()) break + let exists = false + for (let i = 0; i < transaction.pool.length; i++) + if (transaction.pool[i].hash === qItem[y].hash) + exists = true + if (!exists) + transaction.pool.push(qItem[y]) + } + } + } finally { + transaction.poolLock = false + } }, isPoolFull: () => { if (transaction.pool.length >= max_mempool) { @@ -39,19 +79,56 @@ let transaction = { return false }, removeFromPool: (txs) => { - for (let y = 0; y < txs.length; y++) - for (let i = 0; i < transaction.pool.length; i++) - if (transaction.pool[i].hash === txs[y].hash) { - transaction.pool.splice(i, 1) - break - } + if (transaction.poolLock) { + transaction.removalQueue = transaction.removalQueue || [] + for (let y = 0; y < txs.length; y++) + transaction.removalQueue.push(txs[y]) + return + } + transaction.poolLock = true + try { + for (let y = 0; y < txs.length; y++) + for (let i = transaction.pool.length - 1; i >= 0; i--) + if (transaction.pool[i].hash === txs[y].hash) { + transaction.pool.splice(i, 1) + break + } + // drain pending removals while we hold the lock + if (transaction.removalQueue) + for (let y = 0; y < transaction.removalQueue.length; y++) + for (let i = transaction.pool.length - 1; i >= 0; i--) + if (transaction.pool[i].hash === transaction.removalQueue[y].hash) { + transaction.pool.splice(i, 1) + break + } + transaction.removalQueue = [] + } finally { + transaction.poolLock = false + } }, cleanPool: () => { - for (let i = 0; i < transaction.pool.length; i++) - if (transaction.pool[i].ts + config.txExpirationTime < new Date().getTime()) { - transaction.pool.splice(i,1) - i-- - } + if (transaction.poolLock) { + transaction.cleanPoolPending = true + return + } + transaction.poolLock = true + try { + for (let i = transaction.pool.length - 1; i >= 0; i--) + if (transaction.pool[i].ts + config.txExpirationTime < new Date().getTime()) + transaction.pool.splice(i,1) + // also drain removal queue if any + if (transaction.removalQueue) + for (let y = 0; y < transaction.removalQueue.length; y++) + for (let i = transaction.pool.length - 1; i >= 0; i--) + if (transaction.pool[i].hash === transaction.removalQueue[y].hash) { + transaction.pool.splice(i, 1) + break + } + transaction.removalQueue = [] + transaction.cleanPoolPending = false + } finally { + transaction.poolLock = false + } }, isInPool: (tx) => { let isInPool = false @@ -63,7 +140,7 @@ let transaction = { return isInPool }, isPublished: (tx) => { - if (!tx.hash) return + if (!tx.hash) return false if (chain.recentTxs[tx.hash]) return true return false @@ -125,7 +202,9 @@ let transaction = { let newTx = cloneDeep(tx) delete newTx.signature delete newTx.hash - let computedHash = CryptoJS.SHA256(JSON.stringify(newTx)).toString() + let computedHash = crypto.createHash('sha256').update(JSON.stringify(newTx)).digest('hex') + if (skiphash[tx.hash] && skiphash[tx.hash] === computedHash && !(!p2p.recovering && chain.getLatestBlock()._id > chain.restoredBlocks)) + logr.warn('SKIPHASH used for tx', tx.hash, tx) if (computedHash !== tx.hash && (skiphash[tx.hash] !== computedHash || (!p2p.recovering && chain.getLatestBlock()._id > chain.restoredBlocks))) { cb(false, 'invalid tx hash does not match'); return } @@ -133,7 +212,7 @@ let transaction = { // skipped during replays or rebuilds if (!p2p.recovering && chain.getLatestBlock()._id > chain.restoredBlocks && Transaction.transactions[tx.type].bsonValidate) { let bsonified = bson.deserialize(bson.serialize(newTx)) - let bsonifiedHash = CryptoJS.SHA256(JSON.stringify(bsonified)).toString() + let bsonifiedHash = crypto.createHash('sha256').update(JSON.stringify(bsonified)).digest('hex') if (computedHash !== bsonifiedHash) return cb(false, 'unserializable transaction, perhaps due to non-utf8 character?') } @@ -157,8 +236,8 @@ let transaction = { } // checking if the user has enough bandwidth - if (JSON.stringify(tx).length > newBw.v && tx.sender !== config.masterName) { - cb(false, 'need more bandwidth ('+(JSON.stringify(tx).length-newBw.v)+' B)'); return + if (Buffer.byteLength(JSON.stringify(tx), 'utf8') > newBw.v) { + cb(false, 'need more bandwidth ('+(Buffer.byteLength(JSON.stringify(tx), 'utf8')-newBw.v)+' B)'); return } // check transaction specifics @@ -191,7 +270,7 @@ let transaction = { growth: Math.max(account.baseBwGrowth || 0, account.balance)/(config.bwGrowth), max: config.bwMax }) - let needed_bytes = JSON.stringify(tx).length + let needed_bytes = Buffer.byteLength(JSON.stringify(tx), 'utf8') let bw = bandwidth.grow(ts) if (!bw) throw 'No bandwidth error' diff --git a/src/transactions/accountAuthorize.js b/src/transactions/accountAuthorize.js index cb7d2f4..301c1ca 100644 --- a/src/transactions/accountAuthorize.js +++ b/src/transactions/accountAuthorize.js @@ -30,7 +30,7 @@ module.exports = { else if (config.maxKeys && account.auths && account.auths.length >= config.maxKeys) return cb(false, 'cannot add more than ' + config.maxKeys + ' account auths') else if (account.auths) - for (let i in account.auths) + for (let i = 0; i < account.auths.length; i++) if (account.auths[i].user === tx.data.user && account.auths[i].id === tx.data.id) return cb(false, 'account auth already exist') cb(true) diff --git a/src/transactions/approveNode.js b/src/transactions/approveNode.js index cbc7e84..d9e3654 100644 --- a/src/transactions/approveNode.js +++ b/src/transactions/approveNode.js @@ -6,7 +6,7 @@ module.exports = { } cache.findOne('accounts', {name: tx.sender}, function(err, acc) { - if (err) throw err + if (err) { logr.error('approveNode error', err); return cb(false, 'internal error') } if (!acc.approves) acc.approves = [] if (acc.approves.indexOf(tx.data.target) > -1) { cb(false, 'invalid tx already voting'); return @@ -32,7 +32,7 @@ module.exports = { {$push: {approves: tx.data.target}}, function() { cache.findOne('accounts', {name: tx.sender}, function(err, acc) { - if (err) throw err + if (err) { logr.error('approveNode error', err); return cb(false, 'internal error') } if (!acc.approves) acc.approves = [] let node_appr = Math.floor(acc.balance/acc.approves.length) let node_appr_before = (acc.approves.length === 1 ? 0 : Math.floor(acc.balance/(acc.approves.length-1))) diff --git a/src/transactions/claimReward.js b/src/transactions/claimReward.js index 5a8028a..846fe5c 100644 --- a/src/transactions/claimReward.js +++ b/src/transactions/claimReward.js @@ -20,7 +20,7 @@ module.exports = { if (content.votes[i].claimed) { cb(false, 'invalid tx reward already claimed'); return } - if (content.votes[i].claimable < 1) { + if (typeof content.votes[i].claimable !== 'number' || content.votes[i].claimable < 1) { cb(false, 'reward too low to be claimed'); return } if (ts - content.votes[i].ts < config.ecoClaimTime) { @@ -36,6 +36,7 @@ module.exports = { }, execute: (tx, ts, cb) => { cache.findOne('contents', {_id: tx.data.author+'/'+tx.data.link}, function(err, content) { + if (!content) return cb(false, 'content not found') for (let i = 0; i < content.votes.length; i++) if (content.votes[i].u === tx.sender) { let reward = Math.floor(content.votes[i].claimable) @@ -53,7 +54,7 @@ module.exports = { _id: content.author+'/'+content.link+'/claim/'+tx.sender }, function() { cache.findOne('accounts', {name: tx.sender}, function(err, curator) { - if (err) throw err + if (err) { logr.error('claimReward error', err); cb(false); return } // update his bandwidth curator.balance -= reward transaction.updateGrowInts(curator, ts, function() { diff --git a/src/transactions/comment.js b/src/transactions/comment.js index 36b74b5..7a27139 100644 --- a/src/transactions/comment.js +++ b/src/transactions/comment.js @@ -55,7 +55,7 @@ module.exports = { }, execute: (tx, ts, cb) => { cache.findOne('contents', {_id: tx.sender+'/'+tx.data.link}, function(err, content) { - if (err) throw err + if (err) { logr.error('comment error', err); return cb(false, 'internal error') } if (content && process.env.CONTENTS === '1') // existing content being edited cache.updateOne('contents', {_id: tx.sender+'/'+tx.data.link}, { diff --git a/src/transactions/dao/chainUpdateCreate.js b/src/transactions/dao/chainUpdateCreate.js index addb5b9..a035625 100644 --- a/src/transactions/dao/chainUpdateCreate.js +++ b/src/transactions/dao/chainUpdateCreate.js @@ -25,7 +25,7 @@ module.exports = { // array of two-element arrays specifying parameter name and value let changesObj = {} let groupChanges = [] - for (let p in tx.data.changes) + for (let p = 0; p < tx.data.changes.length; p++) if (!validate.array(tx.data.changes[p]) || tx.data.changes[p].length !== 2 || !validate.string(tx.data.changes[p][0])) return cb(false, 'invalid chain update change #'+p) else if (!cc.parameters[tx.data.changes[p][0]]) @@ -38,19 +38,23 @@ module.exports = { changesObj[tx.data.changes[p][0]] = tx.data.changes[p][1] // check for group changes that must be bundled together in the proposal - for (let p in changesObj) - if (cc.groupsInv[p] && !groupChanges.includes(cc.groupsInv[p])) { - for (let member in cc.groups[cc.groupsInv[p]].members) - if (!changesObj[cc.groups[cc.groupsInv[p]].members[member]]) - return cb(false, 'incomplete parameter group '+cc.groupsInv[p]) - groupChanges.push(cc.groupsInv[p]) + for (let p = 0; p < Object.keys(changesObj).length; p++) { + const key = Object.keys(changesObj)[p] + if (cc.groupsInv[key] && !groupChanges.includes(cc.groupsInv[key])) { + const groupMembers = cc.groups[cc.groupsInv[key]].members + for (let m = 0; m < groupMembers.length; m++) + if (!changesObj[groupMembers[m]]) + return cb(false, 'incomplete parameter group '+cc.groupsInv[key]) + groupChanges.push(cc.groupsInv[key]) } + } // validate parameter values as a group - for (let g in groupChanges) { + for (let g = 0; g < groupChanges.length; g++) { let memberValues = [] - for (let p in cc.groups[groupChanges[g]].members) - memberValues.push(changesObj[cc.groups[groupChanges[g]].members[p]]) + const groupMembers = cc.groups[groupChanges[g]].members + for (let m = 0; m < groupMembers.length; m++) + memberValues.push(changesObj[groupMembers[m]]) if (!cc.groups[groupChanges[g]].validate(...memberValues)) return cb(false, 'validation failed for parameter values in group '+groupChanges[g]) } diff --git a/src/transactions/dao/fundRequestWorkReview.js b/src/transactions/dao/fundRequestWorkReview.js index deda46c..732383c 100644 --- a/src/transactions/dao/fundRequestWorkReview.js +++ b/src/transactions/dao/fundRequestWorkReview.js @@ -29,7 +29,7 @@ module.exports = { execute: async (tx, ts, cb) => { let proposal = await cache.findOnePromise('proposals',{ _id: tx.data.id }) let existingReviewIdx, existingApprove - for (let r in proposal.reviews) + for (let r = 0; r < proposal.reviews.length; r++) if (proposal.reviews[r].reviewer === tx.sender) { existingReviewIdx = r existingApprove = proposal.reviews[r].approve diff --git a/src/transactions/dao/proposalEdit.js b/src/transactions/dao/proposalEdit.js index 20d6be2..a3e9971 100644 --- a/src/transactions/dao/proposalEdit.js +++ b/src/transactions/dao/proposalEdit.js @@ -1,4 +1,4 @@ -const dao = require("../../dao") +const dao = require('../../dao') module.exports = { bsonValidate: true, @@ -28,7 +28,7 @@ module.exports = { let status = dao.getFundRequestStatus(proposal,ts) if (status !== dao.fundRequestStatus.votingActive && status !== dao.fundRequestStatus.fundingActive) - return cb(false, 'cannot edit inactive proposals or fund requests past its funding stage') + return cb(false, 'cannot edit inactive proposals or fund requests past its funding stage') } else if (proposal.type === dao.governanceTypes.chainUpdate) { let status = dao.getChainUpdateStatus(proposal,ts) if (status !== dao.chainUpdateStatus.votingActive) diff --git a/src/transactions/dao/proposalVote.js b/src/transactions/dao/proposalVote.js index 195846d..0552509 100644 --- a/src/transactions/dao/proposalVote.js +++ b/src/transactions/dao/proposalVote.js @@ -1,4 +1,4 @@ -const dao = require("../../dao") +const dao = require('../../dao') module.exports = { fields: ['id','amount'], @@ -19,7 +19,7 @@ module.exports = { if (proposal.votingEnds < ts) return cb(false, 'proposal voting period already ended') if (voter.proposalVotes) - for (let v in voter.proposalVotes) + for (let v = 0; v < voter.proposalVotes.length; v++) if (voter.proposalVotes[v].id === tx.data.id) return cb(false, 'already voted on proposal') diff --git a/src/transactions/disaproveNode.js b/src/transactions/disaproveNode.js index 603f1a9..6a72122 100644 --- a/src/transactions/disaproveNode.js +++ b/src/transactions/disaproveNode.js @@ -6,7 +6,7 @@ module.exports = { } cache.findOne('accounts', {name: tx.sender}, function(err, acc) { - if (err) throw err + if (err) { logr.error('disaproveNode error', err); return cb(false, 'internal error') } if (!acc.approves) acc.approves = [] if (acc.approves.indexOf(tx.data.target) === -1) { cb(false, 'invalid tx already unvoted'); return @@ -26,7 +26,7 @@ module.exports = { {$pull: {approves: tx.data.target}}, function() { cache.findOne('accounts', {name: tx.sender}, function(err, acc) { - if (err) throw err + if (err) { logr.error('disaproveNode error', err); return cb(false, 'internal error') } if (!acc.approves) acc.approves = [] let node_appr = (acc.approves.length === 0 ? 0 : Math.floor(acc.balance/acc.approves.length)) let node_appr_before = Math.floor(acc.balance/(acc.approves.length+1)) diff --git a/src/transactions/follow.js b/src/transactions/follow.js index 9b9fcd4..5076e6e 100644 --- a/src/transactions/follow.js +++ b/src/transactions/follow.js @@ -6,7 +6,7 @@ module.exports = { } cache.findOne('accounts', {name: tx.sender}, function(err, acc) { - if (err) throw err + if (err) { logr.error('follow error', err); return cb(false, 'internal error') } if (!acc.follows) acc.follows = [] if (acc.follows.indexOf(tx.data.target) > -1) { cb(false, 'invalid tx already following'); return diff --git a/src/transactions/newAccount.js b/src/transactions/newAccount.js index 6751986..c5a1cbc 100644 --- a/src/transactions/newAccount.js +++ b/src/transactions/newAccount.js @@ -25,12 +25,12 @@ module.exports = { } cache.findOne('accounts', {name: lowerUser}, function(err, account) { - if (err) throw err + if (err) { logr.error('newAccount error', err); return cb(false, 'internal error') } if (account) cb(false, 'invalid tx data.name already exists') else cache.findOne('accounts', {name: tx.sender}, function(err, account) { - if (err) throw err + if (err) { logr.error('newAccount error', err); return cb(false, 'internal error') } if (dao.availableBalance(account,ts) < eco.accountPrice(lowerUser)) cb(false, 'invalid tx not enough balance') else @@ -70,7 +70,7 @@ module.exports = { {name: tx.sender}, {$inc: {balance: -eco.accountPrice(tx.data.name)}}, function() { cache.findOne('accounts', {name: tx.sender}, function(err, acc) { - if (err) throw err + if (err) { logr.error('newAccount error', err); return cb(false, 'internal error') } // update his bandwidth acc.balance += eco.accountPrice(tx.data.name) transaction.updateGrowInts(acc, ts, function() { diff --git a/src/transactions/newAccountWithBw.js b/src/transactions/newAccountWithBw.js index b533ec2..785cbdf 100644 --- a/src/transactions/newAccountWithBw.js +++ b/src/transactions/newAccountWithBw.js @@ -10,9 +10,9 @@ module.exports = { if (!valid) return cb(false,error) cache.findOne('accounts', {name: tx.sender}, function(err, account) { - if (err) throw err + if (err) { logr.error('newAccountWithBw error', err); return cb(false, 'internal error') } let bwBefore = new GrowInt(account.bw, {growth:Math.max(account.baseBwGrowth || 0, account.balance)/(config.bwGrowth)}).grow(ts) - if (bwBefore.v < tx.data.amount) + if (bwBefore.v < tx.data.bw) cb(false, 'invalid tx not enough bw') else cb(true) @@ -52,7 +52,7 @@ module.exports = { {name: tx.sender}, {$inc: {balance: -eco.accountPrice(tx.data.name)}}, function() { cache.findOne('accounts', {name: tx.sender}, function(err, acc) { - if (err) throw err + if (err) { logr.error('newAccountWithBw error', err); return cb(false, 'internal error') } // update his bandwidth acc.balance += eco.accountPrice(tx.data.name) transaction.updateGrowInts(acc, ts, function() { diff --git a/src/transactions/playlistPop.js b/src/transactions/playlistPop.js index 2547b3b..ead91b7 100644 --- a/src/transactions/playlistPop.js +++ b/src/transactions/playlistPop.js @@ -13,7 +13,7 @@ module.exports = { return cb(false, 'invalid array of sequences to be removed') // validate playlist sequence number to be deleted - for (let s in tx.data.seq) + for (let s = 0; s < tx.data.seq.length; s++) if (!validate.integer(tx.data.seq[s],true,false,config.playlistSequenceIdMax)) return cb(false,'invalid playlist sequence '+s) @@ -22,7 +22,7 @@ module.exports = { execute: (tx, ts, cb) => { cache.findOne('playlists',{_id: tx.sender+'/'+tx.data.link},(e,p) => { let newPlaylist = p.playlist - for (let s in tx.data.seq) + for (let s = 0; s < tx.data.seq.length; s++) delete newPlaylist[tx.data.seq[s]] cache.updateOne('playlists',{_id: tx.sender+'/'+tx.data.link}, { $set: { playlist: newPlaylist } diff --git a/src/transactions/playlistPush.js b/src/transactions/playlistPush.js index dfc1c7e..3be463f 100644 --- a/src/transactions/playlistPush.js +++ b/src/transactions/playlistPush.js @@ -17,7 +17,7 @@ module.exports = { if (!p) return cb(false, 'playlist does not exist') let newContents = 0 - for (let s in tx.data.seq) { + for (let s = 0; s < tx.data.seq.length; s++) { if (!validate.array(tx.data.seq[s],2)) return cb(false, 'invalid playlist seq index #'+s+' array') @@ -41,7 +41,7 @@ module.exports = { }, execute: (tx, ts, cb) => { cache.findOne('playlists',{_id: tx.sender+'/'+tx.data.link},(e,p) => { - for (let s in tx.data.seq) + for (let s = 0; s < tx.data.seq.length; s++) p.playlist[tx.data.seq[s][0]] = tx.data.seq[s][1] cache.updateOne('playlists',{_id: tx.sender+'/'+tx.data.link}, { $set: { playlist: p.playlist } diff --git a/src/transactions/promotedComment.js b/src/transactions/promotedComment.js index f883b5d..4717790 100644 --- a/src/transactions/promotedComment.js +++ b/src/transactions/promotedComment.js @@ -9,7 +9,7 @@ module.exports = { cb(false, 'invalid tx data.link'); return } cache.findOne('contents', {_id: tx.sender+'/'+tx.data.link}, function(err, content) { - if (err) throw err + if (err) { logr.error('promotedComment error', err); return cb(false, 'internal error') } if (content) { cb(false, 'cannot edit and promote'); return } @@ -26,9 +26,11 @@ module.exports = { cb(false, 'invalid tx data.burn'); return } cache.findOne('accounts', {name: tx.sender}, function(err, account) { - if (err) throw err + if (err) { logr.error('promotedComment error', err); return cb(false, 'internal error') } if (dao.availableBalance(account,ts) < tx.data.burn) return cb(false, 'invalid tx not enough balance to burn') + if (!Number.isSafeInteger(tx.data.vt + (tx.data.burn * config.vtPerBurn))) + return cb(false, 'vt overflow') cb(true) }) } else diff --git a/src/transactions/setSignThreshold.js b/src/transactions/setSignThreshold.js index 65ed566..39e4053 100644 --- a/src/transactions/setSignThreshold.js +++ b/src/transactions/setSignThreshold.js @@ -7,7 +7,9 @@ module.exports = { if (!validate.json(tx.data.thresholds,config.jsonMaxBytes)) return cb(false, 'invalid tx data.threshold json') - for (let t in tx.data.thresholds) { + const thresholdKeys = Object.keys(tx.data.thresholds) + for (let ti = 0; ti < thresholdKeys.length; ti++) { + const t = thresholdKeys[ti] if (t !== 'default' && (t !== parseInt(t).toString() || !validate.integer(parseInt(t),true,false))) return cb(false, 'invalid tx type ' + t) diff --git a/src/transactions/tippedVote.js b/src/transactions/tippedVote.js index 511f5ab..1b49a34 100644 --- a/src/transactions/tippedVote.js +++ b/src/transactions/tippedVote.js @@ -24,7 +24,7 @@ module.exports = { return cb(false, 'invalid author tip value') cache.findOne('contents', {_id: tx.data.author+'/'+tx.data.link}, (err, content) => { - if (err) throw err + if (err) { logr.error('tippedVote error', err); return cb(false, 'internal error') } if (!content) return cb(false, 'cannot vote and tip non-existent content') if (content.votes.length === 0) return cb(false, 'no votes in this content to tip author with') diff --git a/src/transactions/transfer.js b/src/transactions/transfer.js index c3fb927..580a784 100644 --- a/src/transactions/transfer.js +++ b/src/transactions/transfer.js @@ -18,12 +18,12 @@ module.exports = { } cache.findOne('accounts', {name: tx.sender}, function(err, account) { - if (err) throw err + if (err) { logr.error('transfer error', err); return cb(false, 'internal error') } if (dao.availableBalance(account,ts) < tx.data.amount) return cb(false, 'invalid tx not enough balance') cache.findOne('accounts', {name: tx.data.receiver}, function(err, account) { - if (err) throw err + if (err) { logr.error('transfer error', err); return cb(false, 'internal error') } if (!account) cb(false, 'invalid tx receiver does not exist') else cb(true) }) @@ -36,7 +36,7 @@ module.exports = { {$inc: {balance: -tx.data.amount}}, function() { cache.findOne('accounts', {name: tx.sender}, function(err, accSender) { - if (err) throw err + if (err) { logr.error('transfer error', err); return cb(false, 'internal error') } // update his bandwidth accSender.balance += tx.data.amount transaction.updateGrowInts(accSender, ts, function() { @@ -49,7 +49,7 @@ module.exports = { {$inc: {balance: tx.data.amount}}, function() { cache.findOne('accounts', {name: tx.data.receiver}, function(err, accReceiver) { - if (err) throw err + if (err) { logr.error('transfer error', err); return cb(false, 'internal error') } // update his bandwidth accReceiver.balance -= tx.data.amount transaction.updateGrowInts(accReceiver, ts, function() { diff --git a/src/transactions/transferBw.js b/src/transactions/transferBw.js index 1de7b6c..b16d91d 100644 --- a/src/transactions/transferBw.js +++ b/src/transactions/transferBw.js @@ -10,13 +10,13 @@ module.exports = { cb(false, 'invalid tx data.amount'); return } cache.findOne('accounts', {name: tx.sender}, function(err, account) { - if (err) throw err + if (err) { logr.error('transferBw error', err); return cb(false, 'internal error') } let bwBefore = new GrowInt(account.bw, {growth:account.balance/(config.bwGrowth)}).grow(ts) if (bwBefore.v < tx.data.amount) { cb(false, 'invalid tx not enough bw'); return } cache.findOne('accounts', {name: tx.data.receiver}, function(err, account) { - if (err) throw err + if (err) { logr.error('transferBw error', err); return cb(false, 'internal error') } if (!account) cb(false, 'invalid tx receiver does not exist') else cb(true) }) @@ -26,7 +26,7 @@ module.exports = { if (config.burnAccountIsBlackhole && tx.data.receiver === config.burnAccount) return cb(true) cache.findOne('accounts', {name: tx.data.receiver}, function(err, account) { - if (err) throw err + if (err) { logr.error('transferBw error', err); return cb(false, 'internal error') } account.bw.v += tx.data.amount cache.updateOne('accounts', {name: tx.data.receiver}, {$set: {bw: account.bw}}, function() { cb(true) diff --git a/src/transactions/transferVt.js b/src/transactions/transferVt.js index e70558b..c59024e 100644 --- a/src/transactions/transferVt.js +++ b/src/transactions/transferVt.js @@ -11,7 +11,7 @@ module.exports = { if (vpCheck.needs) return cb(false, 'not enough VP, attempting to spend '+tx.data.amount+' VP but only has '+vpCheck.has+' VP') cache.findOne('accounts', {name: tx.data.receiver}, function(err, account) { - if (err) throw err + if (err) { logr.error('transferVt error', err); return cb(false, 'internal error') } if (!account) cb(false, 'invalid tx receiver does not exist') else cb(true) }) @@ -21,7 +21,7 @@ module.exports = { if (config.burnAccountIsBlackhole && tx.data.receiver === config.burnAccount) return cb(true) cache.findOne('accounts', {name: tx.data.receiver}, function(err, account) { - if (err) throw err + if (err) { logr.error('transferVt error', err); return cb(false, 'internal error') } account.vt.v += tx.data.amount cache.updateOne('accounts', {name: tx.data.receiver}, {$set: {vt: account.vt}}, function() { cb(true) diff --git a/src/transactions/unfollow.js b/src/transactions/unfollow.js index f005b97..b1ab337 100644 --- a/src/transactions/unfollow.js +++ b/src/transactions/unfollow.js @@ -6,7 +6,7 @@ module.exports = { } cache.findOne('accounts', {name: tx.sender}, function(err, acc) { - if (err) throw err + if (err) { logr.error('unfollow error', err); return cb(false, 'internal error') } if (!acc.follows) acc.follows = [] if (acc.follows.indexOf(tx.data.target) === -1) { cb(false, 'invalid tx not following target'); return diff --git a/src/transactions/unsetSignThreshold.js b/src/transactions/unsetSignThreshold.js index f5ced28..6a1a8a7 100644 --- a/src/transactions/unsetSignThreshold.js +++ b/src/transactions/unsetSignThreshold.js @@ -7,7 +7,7 @@ module.exports = { if (!validate.array(tx.data.types)) return cb(false, 'types is not a valid array') - for (let t in tx.data.types) + for (let t = 0; t < tx.data.types.length; t++) if (!validate.integer(tx.data.types[t],true,false)) return cb(false, 'invalid type ' + tx.data.types[t] + ' at index ' + t) @@ -17,7 +17,7 @@ module.exports = { cache.findOne('accounts', {name: tx.sender}, (e,acc) => { let newThresholds = acc.thresholds if (newThresholds) { - for (let t in tx.data.types) + for (let t = 0; t < tx.data.types.length; t++) delete newThresholds[tx.data.types[t]] cache.updateOne('accounts', {name: tx.sender}, { $set: { thresholds: newThresholds } }, () => cb(true)) } else diff --git a/src/txHistory.js b/src/txHistory.js index a4891c5..1e9b68d 100644 --- a/src/txHistory.js +++ b/src/txHistory.js @@ -5,23 +5,25 @@ let txHistory = { accounts: process.env.TX_HISTORY_ACCOUNTS ? process.env.TX_HISTORY_ACCOUNTS.split(',') : [], processBlock: (block) => { if (process.env.TX_HISTORY !== '1') return - for (let t in block.txs) + for (let t = 0; t < block.txs.length; t++) { + const tx = block.txs[t] if (txHistory.accounts.length === 0 || - txHistory.accounts.includes(block.txs[t].sender) || - txHistory.accounts.includes(block.txs[t].data.target) || - txHistory.accounts.includes(block.txs[t].data.receiver) || - txHistory.accounts.includes(block.txs[t].data.pa) || - txHistory.accounts.includes(block.txs[t].data.author)) { - let newTxItm = cloneDeep(block.txs[t]) + txHistory.accounts.includes(tx.sender) || + txHistory.accounts.includes(tx.data.target) || + txHistory.accounts.includes(tx.data.receiver) || + txHistory.accounts.includes(tx.data.pa) || + txHistory.accounts.includes(tx.data.author)) { + let newTxItm = cloneDeep(tx) newTxItm._id = newTxItm.hash newTxItm.includedInBlock = block._id txHistory.indexQueue.push(newTxItm) } + } }, getWriteOps: () => { if (process.env.TX_HISTORY !== '1') return [] let ops = [] - for (let i in txHistory.indexQueue) { + for (let i = 0; i < txHistory.indexQueue.length; i++) { let newTx = txHistory.indexQueue[i] ops.push((cb) => db.collection('txs').insertOne(newTx,cb)) } diff --git a/src/validate/float.js b/src/validate/float.js index 3b9429b..f69e31c 100644 --- a/src/validate/float.js +++ b/src/validate/float.js @@ -1,9 +1,9 @@ // floating point module.exports = (value, canBeZero, canBeNegative, max, min) => { - if (!max) + if (typeof max === 'undefined') max = Math.pow(2,33)-1 - if (!min) + if (typeof min === 'undefined') if (canBeNegative) min = -Math.pow(2,33)+1 else @@ -11,7 +11,7 @@ module.exports = (value, canBeZero, canBeNegative, max, min) => { if (typeof value !== 'number') return false - if (isNaN(value)) + if (isNaN(value) || !isFinite(value)) return false let parts = value.toString().split('.') if (parts.length > 2) diff --git a/src/validate/integer.js b/src/validate/integer.js index 442189e..6b0cb48 100644 --- a/src/validate/integer.js +++ b/src/validate/integer.js @@ -2,9 +2,9 @@ // vt (can be negative but still non zero) module.exports = (value, canBeZero, canBeNegative, max, min) => { - if (!max) + if (typeof max === 'undefined') max = Number.MAX_SAFE_INTEGER - if (!min) + if (typeof min === 'undefined') if (canBeNegative) min = Number.MIN_SAFE_INTEGER else diff --git a/src/validate/json.js b/src/validate/json.js index f33dbe3..cd08483 100644 --- a/src/validate/json.js +++ b/src/validate/json.js @@ -1,12 +1,24 @@ // content json and profile +function hasInvalidKeys(obj) { + if (Array.isArray(obj)) + return obj.some(hasInvalidKeys) + if (obj && typeof obj === 'object') + for (const k of Object.keys(obj)) + if (k.includes('.') || k.includes('$') || hasInvalidKeys(obj[k])) + return true + return false +} + module.exports = (value, max) => { if (!value) return false if (typeof value !== 'object') return false + if (hasInvalidKeys(value)) + return false try { - if (JSON.stringify(value).length > max) + if (Buffer.byteLength(JSON.stringify(value), 'utf8') > max) return false } catch (error) { return false diff --git a/src/validate/string.js b/src/validate/string.js index 946fe4f..f8a28d1 100644 --- a/src/validate/string.js +++ b/src/validate/string.js @@ -3,9 +3,9 @@ // key identifier module.exports = (value, maxLength, minLength, allowedChars, allowedCharsMiddle) => { - if (!maxLength) + if (typeof maxLength === 'undefined') maxLength = Number.MAX_SAFE_INTEGER - if (!minLength) + if (typeof minLength === 'undefined') minLength = 0 if (typeof value !== 'string') return false @@ -18,7 +18,7 @@ module.exports = (value, maxLength, minLength, allowedChars, allowedCharsMiddle) if (allowedChars.indexOf(value[i]) === -1) if (i === 0 || i === value.length-1) return false - else if (allowedCharsMiddle && allowedCharsMiddle.indexOf(value[i]) === -1) + else if (!allowedCharsMiddle || allowedCharsMiddle.indexOf(value[i]) === -1) return false return true diff --git a/test/audit-fixes.js b/test/audit-fixes.js new file mode 100644 index 0000000..7e6ed7d --- /dev/null +++ b/test/audit-fixes.js @@ -0,0 +1,354 @@ +// == Audit Fixes Integration Tests == +// Tests all fixes from the security/consensus audit + +const assert = require('assert') +const crypto = require('crypto') +const path = require('path') +const fs = require('fs') + +let passed = 0 +let failed = 0 + +function test(name, fn) { + try { + fn() + console.log(' PASS: ' + name) + passed++ + } catch (e) { + console.log(' FAIL: ' + name + ' \u2014 ' + e.message) + failed++ + } +} + +console.log('=== Audit Fix Verification ===\n') + +// 1. tryNextStepBusy lock pattern +console.log('--- consensus.js: tryNextStepBusy lock ---') +test('tryNextStepBusy prevents concurrent tryNextStep execution', () => { + let busy = false + let deferredCalls = 0 + function tryNextStep() { + if (busy) { deferredCalls++; return } + busy = true + busy = false + } + tryNextStep() + busy = true + tryNextStep() + assert.strictEqual(deferredCalls, 1) + busy = false +}) + +// 2. Fixed quorum threshold +console.log('\n--- consensus.js: Fixed quorum threshold ---') +test('_getQuorumThreshold uses config.leaders (fixed, not activeLeaders)', () => { + const leaders = 7 + const threshold = Math.ceil(leaders * 2 / 3) + assert.strictEqual(threshold, 5) + // Sybil attack: activeLeaders returns 0, old threshold = 0 (bypass!) + const sybilAttack = Math.ceil(0 * 2 / 3) + assert.strictEqual(sybilAttack, 0, 'old: 0 = bypass!') + assert.strictEqual(threshold, 5, 'new: stays at 5') +}) + +test('quorum threshold edge cases', () => { + const calc = (leaders) => Math.ceil(leaders * 2 / 3) + assert.strictEqual(calc(1), 1) + assert.strictEqual(calc(2), 2) + assert.strictEqual(calc(3), 2) + assert.strictEqual(calc(7), 5) + assert.strictEqual(calc(21), 14) + assert.strictEqual(calc(100), 67) +}) + +// 3. candidateRetry >= 3 guard +console.log('\n--- consensus.js: retry loop guard ---') +test('_forceFinalize retry limit at 3', () => { + const MAX = 3 + function ff(retry) { + if (retry === undefined) retry = 0 + if (retry >= MAX) return 'EXCEEDED' + return 'OK' + } + assert.strictEqual(ff(0), 'OK') + assert.strictEqual(ff(1), 'OK') + assert.strictEqual(ff(2), 'OK') + assert.strictEqual(ff(3), 'EXCEEDED') + assert.strictEqual(ff(4), 'EXCEEDED') +}) + +// 4. fromNow guard +console.log('\n--- consensus.js: fromNow sanitization ---') +test('scheduleForceFinalize bails on fromNow > 86400000', () => { + function schedule(fromNow) { + if (fromNow > 86400000) return 'SKIPPED' + return 'SCHEDULED' + } + assert.strictEqual(schedule(1000), 'SCHEDULED') + assert.strictEqual(schedule(60000), 'SCHEDULED') + assert.strictEqual(schedule(86400000), 'SCHEDULED') + assert.strictEqual(schedule(86400001), 'SKIPPED') +}) + +// 5. Empty shuffle guard +console.log('\n--- consensus.js: empty shuffle guard ---') +test('activeLeaders handles empty shuffle', () => { + function activeLeaders(shuffle) { + if (!shuffle || shuffle.length === 0) return [] + return shuffle.map(s => s.name) + } + assert.strictEqual(activeLeaders([]).length, 0) + assert.strictEqual(activeLeaders(null).length, 0) + assert.strictEqual(activeLeaders(undefined).length, 0) + assert.strictEqual(activeLeaders([{name:'a'}]).length, 1) +}) + +// 6. MINE_TOKEN validation +console.log('\n--- mineBlock/index.js: MINE_TOKEN ---') +test('mineBlock: no token required when MINE_TOKEN unset', () => { + function handler(requiredToken, queryToken) { + if (requiredToken && queryToken !== requiredToken) return { status: 401 } + return { status: 200 } + } + let r = handler(undefined, 'anything') + assert.strictEqual(r.status, 200) + + r = handler('my-secret', 'wrong') + assert.strictEqual(r.status, 401) + + r = handler('my-secret', 'my-secret') + assert.strictEqual(r.status, 200) +}) + +test('requireAuth: fails closed when no admin token is set', () => { + const auth = require('../src/http/auth') + const saved = {} + const vars = ['ADMIN_TOKEN', 'LOG_ADMIN_TOKEN', 'MINE_TOKEN', 'DEBUG_TOKEN', 'RECOVER_TOKEN'] + for (const v of vars) { saved[v] = process.env[v]; delete process.env[v] } + const savedAnon = process.env.ADMIN_ALLOW_ANONYMOUS + delete process.env.ADMIN_ALLOW_ANONYMOUS + + // Mock req/res as seen from `curl http://localhost:3001/mineBlock` + const req = { + headers: { accept: '*/*' }, + query: {}, + socket: { remoteAddress: '127.0.0.1' } + } + let res + const newRes = () => ({ + statusCode: 200, + status(c) { this.statusCode = c; return this }, + set() { return this }, + json() { this.body = { json: true }; return this }, + send(b) { this.body = b; return this } + }) + + // No tokens configured -> FAIL CLOSED: no anonymous admin access + let nextCalled = false + res = newRes() + auth.requireAuth()(req, res, () => { nextCalled = true }) + assert.strictEqual(nextCalled, false, 'no tokens set: next() must NOT be called (fail closed)') + assert.strictEqual(res.statusCode, 401, 'no tokens set: must answer 401') + + // ...unless the operator explicitly opts in to anonymous access + process.env.ADMIN_ALLOW_ANONYMOUS = '1' + nextCalled = false + res = newRes() + auth.requireAuth()(req, res, () => { nextCalled = true }) + assert.strictEqual(nextCalled, true, 'ADMIN_ALLOW_ANONYMOUS=1: next() should be called') + delete process.env.ADMIN_ALLOW_ANONYMOUS + + // With ADMIN_TOKEN set -> curl without token still gets 401 + login HTML + process.env.ADMIN_TOKEN = 'secret' + nextCalled = false + res = newRes() + auth.requireAuth()(req, res, () => { nextCalled = true }) + assert.strictEqual(nextCalled, false, 'token set: next() must not be called') + assert.strictEqual(res.statusCode, 401) + assert.ok(String(res.body).includes(' correct token (query param) is accepted + const reqToken = { headers: { accept: '*/*' }, query: { token: 'secret' }, socket: { remoteAddress: '127.0.0.1' } } + nextCalled = false + res = newRes() + res.req = reqToken + auth.requireAuth()(reqToken, res, () => { nextCalled = true }) + assert.strictEqual(nextCalled, true, 'valid token should be accepted') + + for (const v of vars) { + if (saved[v] === undefined) delete process.env[v] + else process.env[v] = saved[v] + } + auth.sessions.clear() +}) + +// 7. DEBUG_TOKEN validation +console.log('\n--- debug/index.js: DEBUG_TOKEN ---') +test('debug: no token required when DEBUG_TOKEN unset', () => { + function debugHandler(token, dt) { + if (dt && token !== dt) return { status: 401 } + return { status: 200 } + } + let r = debugHandler('anything', undefined) + assert.strictEqual(r.status, 200) + + r = debugHandler('secret', 'secret') + assert.strictEqual(r.status, 200) + + r = debugHandler('wrong', 'secret') + assert.strictEqual(r.status, 401) +}) + +// 8. DNS rebinding protection +console.log('\n--- image/index.js: DNS rebinding protection ---') +test('resolveAndPin + checkRebinding prevents DNS rebinding', async () => { + const dns = require('dns').promises + const net = require('net') + + async function resolveAndPin(host) { + if (net.isIP(host)) return host + try { + const lookup = await dns.lookup(host, {family: 4}) + return lookup.address + } catch { return null } + } + + async function checkRebinding(host, pinnedIp) { + if (net.isIP(host)) return pinnedIp === host + try { + const lookup = await dns.lookup(host, {family: 4}) + return lookup.address === pinnedIp + } catch { return false } + } + + const ip = await resolveAndPin('localhost') + assert.strictEqual(ip, '127.0.0.1') + + const ok = await checkRebinding('localhost', ip) + assert.strictEqual(ok, true) + + const fail = await checkRebinding('localhost', '1.2.3.4') + assert.strictEqual(fail, false) + + const dOk = await checkRebinding('8.8.8.8', '8.8.8.8') + assert.strictEqual(dOk, true) + const dFail = await checkRebinding('8.8.8.8', '1.1.1.1') + assert.strictEqual(dFail, false) +}) + +// 9. BSON position calculation +console.log('\n--- auto_resolve_halt.sh: BSON truncPos ---') +test('truncPos = (BigInt(high) << 8n) + BigInt(low)', () => { + // Node encoding (src/blocks.js appendIndex/read): high = pos >> 8, low = pos & 0xFF, + // so the decode must mirror it: pos = (high << 8) + low + function calc(high, low) { return (BigInt(high) << 8n) + BigInt(low) } + function wrongCalc(high, low) { return (BigInt(high) << 32n) + BigInt(low) } + + assert.strictEqual(calc(0, 255), 255n) + assert.strictEqual(calc(3, 232), 1000n) + assert.strictEqual(calc(17578125, 0), 4500000000n) + assert.strictEqual(calc(33554432, 0), 8589934592n) + + // The << 32 decode explodes any real offset (>= 256) past every file size + assert.strictEqual(wrongCalc(3, 232), 12884902120n) + assert.notStrictEqual(calc(3, 232), wrongCalc(3, 232)) +}) + +// 10. Miner log sanitization +console.log('\n--- chain.js: miner log sanitization ---') +test('block.miner sanitized in output', () => { + function sanitize(m) { return (m || '').replace(/[\x00-\x1f]/g, '') } + assert.strictEqual(sanitize('alice'), 'alice') + assert.strictEqual(sanitize('bob\x00'), 'bob') + assert.strictEqual(sanitize('\x1b[2J'), '[2J') + assert.strictEqual(sanitize('\n\r\t'), '') + assert.strictEqual(sanitize(undefined), '') + assert.strictEqual(sanitize(null), '') +}) + +// 11. Rate limiter on /transact +console.log('\n--- transact/index.js: rate limiter ---') +test('POST /transact has rate limiter', () => { + const content = fs.readFileSync(path.join(__dirname, '../src/http/transact/index.js'), 'utf8') + assert.ok(content.includes("require('express-rate-limit')")) + assert.ok(content.includes('txLimiter')) + assert.ok(content.includes("app.post('/transact', txLimiter,")) +}) + +// 12. auto_resolve_halt.sh MongoDB eval uses env vars +console.log('\n--- auto_resolve_halt.sh: MongoDB eval injection fix ---') +function readScript(name) { + const hostPath = path.join(__dirname, '../scripts', name) + if (fs.existsSync(hostPath)) return fs.readFileSync(hostPath, 'utf8') + const dockerPath = path.join(__dirname, '../project-scripts', name) + if (fs.existsSync(dockerPath)) return fs.readFileSync(dockerPath, 'utf8') + throw new Error('cannot find ' + name) +} +test('mongo eval uses process.env instead of bash interpolation', () => { + const content = readScript('auto_resolve_halt.sh') + assert.ok(content.includes('process.env.REMOVE_COUNT')) + assert.ok(content.includes('process.env.DRY_RUN')) +}) + +// 13. File integrity checks +console.log('\n--- File integrity checks ---') +test('consensus.js has tryNextStepBusy', () => { + const c = fs.readFileSync(path.join(__dirname, '../src/consensus.js'), 'utf8') + assert.ok(c.includes('tryNextStepBusy')) + assert.ok(c.includes('tryNextStepBusy: false')) +}) + +test('consensus.js uses config.leaders for quorum', () => { + const c = fs.readFileSync(path.join(__dirname, '../src/consensus.js'), 'utf8') + assert.ok(c.includes('config.leaders * 2 / 3')) +}) + +test('consensus.js has empty shuffle guard', () => { + const c = fs.readFileSync(path.join(__dirname, '../src/consensus.js'), 'utf8') + assert.ok(c.includes('shuffle.length === 0')) +}) + +test('image/index.js has resolveAndPin + checkRebinding', () => { + const c = fs.readFileSync(path.join(__dirname, '../src/http/image/index.js'), 'utf8') + assert.ok(c.includes('resolveAndPin')) + assert.ok(c.includes('checkRebinding')) +}) + +test('auto_resolve_halt.sh has BSON << 8n', () => { + const c = readScript('auto_resolve_halt.sh') + assert.ok(c.includes('<< 8n')) + assert.ok(!c.includes('<< 32n')) +}) + +// N. TRUST_PROXY parsing (http/index.js) +console.log('\n--- http/index.js: TRUST_PROXY parsing ---') +const { parseTrustProxy } = require('../src/http/index') + +test('TRUST_PROXY: a hop count becomes a number', () => { + assert.strictEqual(parseTrustProxy('1'), 1) + assert.strictEqual(parseTrustProxy('2'), 2) +}) + +test('TRUST_PROXY: off values disable trusting (undefined)', () => { + for (const v of ['0', 'false', 'FALSE', 'no', 'off', '', ' ', undefined, null]) + assert.strictEqual(parseTrustProxy(v), undefined, 'value ' + JSON.stringify(v)) +}) + +test('TRUST_PROXY: keywords accepted, case-insensitive', () => { + assert.strictEqual(parseTrustProxy('loopback'), 'loopback') + assert.strictEqual(parseTrustProxy('LinkLocal'), 'linklocal') + assert.strictEqual(parseTrustProxy('uniquelocal'), 'uniquelocal') +}) + +test('TRUST_PROXY: true/yes/on refused with a clear message', () => { + for (const v of ['true', 'yes', 'on']) + assert.throws(() => parseTrustProxy(v), /TRUST_PROXY/) +}) + +test('TRUST_PROXY: an explicit IP / subnet list passes through', () => { + assert.strictEqual(parseTrustProxy('127.0.0.1,10.0.0.0/8'), '127.0.0.1,10.0.0.0/8') +}) + +// Summary +console.log('\n=== Results: ' + passed + ' passed, ' + failed + ' failed ===') +process.exit(failed > 0 ? 1 : 0) diff --git a/test/force-finalize.js b/test/force-finalize.js new file mode 100644 index 0000000..bf53d2e --- /dev/null +++ b/test/force-finalize.js @@ -0,0 +1,340 @@ +const assert = require('assert') +const crypto = require('crypto') + +function deterministicSort(candidates) { + const sorted = [...candidates] + sorted.sort((a, b) => { + if (a.block.timestamp !== b.block.timestamp) + return a.block.timestamp - b.block.timestamp + return a.block.hash < b.block.hash ? -1 : 1 + }) + return sorted +} + +function makeBlock(height, timestamp, seed) { + const hash = crypto.createHash('sha256').update(seed + height + timestamp).digest('hex') + return { + block: { _id: height, timestamp, hash, miner: 'miner_' + seed } + } +} + +function simulateRetry(candidates, failingHashes) { + const results = [] + let retryCount = 0 + let remaining = [...candidates] + + while (remaining.length > 0 && retryCount < 3) { + const sorted = deterministicSort(remaining) + const winner = sorted[0] + if (failingHashes.includes(winner.block.hash)) { + results.push({ winner: winner.block.hash, status: 'fail' }) + remaining = remaining.filter(pb => pb.block.hash !== winner.block.hash) + retryCount++ + } else { + results.push({ winner: winner.block.hash, status: 'success' }) + return results + } + } + results.push({ status: 'exhausted', remaining: remaining.length, retryCount }) + return results +} + +// Test 1: Deterministic candidate selection (timestamp + hash sorting) +{ + const early = makeBlock(100, 1000, 'a') // timestamp 1000 + const mid = makeBlock(100, 2000, 'b') // timestamp 2000 + const late = makeBlock(100, 3000, 'c') // timestamp 3000 + + const sorted = deterministicSort([mid, late, early]) + assert.strictEqual(sorted[0].block.hash, early.block.hash, 'earliest timestamp should win') + assert.strictEqual(sorted[1].block.hash, mid.block.hash, 'middle timestamp second') + assert.strictEqual(sorted[2].block.hash, late.block.hash, 'latest timestamp last') + console.log('PASS: timestamp sorting') +} + +// Test 2: Hash tiebreaker for same timestamp +{ + const a = makeBlock(100, 1000, 'aaaa') + const b = makeBlock(100, 1000, 'bbbb') + + const sorted = deterministicSort([b, a]) + assert.strictEqual(sorted[0].block.hash < sorted[1].block.hash, true, 'lower hash should win on tie') + const sorted2 = deterministicSort([a, b]) + assert.strictEqual(sorted2[0].block.hash, sorted[0].block.hash, 'sorting should be deterministic regardless of input order') + console.log('PASS: hash tiebreaker') +} + +// Test 3: Sorting is idempotent (same result every time) +{ + const blocks = [makeBlock(100, 3000, 'x'), makeBlock(100, 1000, 'y'), makeBlock(100, 2000, 'z')] + const first = deterministicSort(blocks) + const second = deterministicSort(blocks) + for (let i = 0; i < first.length; i++) + assert.strictEqual(first[i].block.hash, second[i].block.hash, 'sorting must be idempotent') + console.log('PASS: idempotent sorting') +} + +// Test 4: Single candidate (no collision) +{ + const single = [makeBlock(100, 1000, 'only')] + const sorted = deterministicSort(single) + assert.strictEqual(sorted.length, 1, 'single candidate stays single') + assert.strictEqual(sorted[0].block.hash, single[0].block.hash) + console.log('PASS: single candidate') +} + +// Test 5: Retry mechanism - first candidate fails, second succeeds +{ + const blocks = [makeBlock(100, 1000, 'a'), makeBlock(100, 2000, 'b')] + const results = simulateRetry(blocks, [blocks[0].block.hash]) + assert.strictEqual(results.length, 2, 'should try 2 candidates') + assert.strictEqual(results[0].status, 'fail') + assert.strictEqual(results[1].status, 'success') + assert.strictEqual(results[1].winner, blocks[1].block.hash) + console.log('PASS: retry with fallback') +} + +// Test 6: Retry mechanism - all candidates fail +{ + const blocks = [makeBlock(100, 1000, 'a'), makeBlock(100, 2000, 'b'), makeBlock(100, 3000, 'c')] + const allHashes = blocks.map(b => b.block.hash) + const results = simulateRetry(blocks, allHashes) + assert.strictEqual(results[results.length - 1].status, 'exhausted') + assert.strictEqual(results[results.length - 1].retryCount, 3, 'should exhaust 3 retries') + console.log('PASS: all candidates fail after 3 retries') +} + +// Test 7: Retry mechanism - fewer candidates than retries +{ + const blocks = [makeBlock(100, 1000, 'a')] + const results = simulateRetry(blocks, [blocks[0].block.hash]) + assert.strictEqual(results[results.length - 1].status, 'exhausted') + assert.strictEqual(results[results.length - 1].remaining, 0, 'no candidates left') + console.log('PASS: fewer candidates than retries') +} + +// Test 8: Candidates at different heights are not mixed +{ + const h99 = [makeBlock(99, 1000, 'a')] + const h100 = [makeBlock(100, 2000, 'b'), makeBlock(100, 1000, 'c')] + const sorted100 = deterministicSort(h100) + assert.strictEqual(sorted100[0].block._id, 100, 'only height 100 candidates') + assert.strictEqual(sorted100[0].block.hash, h100[1].block.hash, 'earliest timestamp at height 100') + console.log('PASS: height isolation') +} + +// Test 9: BSON truncation boundary logic +{ + function simulateTruncation(oldHeight, removeCount) { + const newHeight = oldHeight - removeCount + if (newHeight < 0) return { error: 'negative height' } + return { newHeight, removed: removeCount, kept: newHeight + 1 } + } + + assert.strictEqual(simulateTruncation(100, 5).newHeight, 95) + assert.strictEqual(simulateTruncation(100, 0).newHeight, 100) + assert.strictEqual(simulateTruncation(0, 0).kept, 1) + assert.strictEqual(simulateTruncation(100, 101).error, 'negative height') + + // Safety: cumulative cap prevents runaway truncation + const MAX_TOTAL_REMOVE = 30 + function checkCumulativeCap(totalRemoved, toRemove) { + return (totalRemoved + toRemove) <= MAX_TOTAL_REMOVE + } + assert.strictEqual(checkCumulativeCap(25, 5), true, 'within cap') + assert.strictEqual(checkCumulativeCap(25, 10), false, 'exceeds cap') + console.log('PASS: BSON truncation boundary logic') +} + +// Test 10: Anti-fork proposal selection +{ + const localWinner = makeBlock(100, 2000, 'local') + const peerWinner = makeBlock(100, 1000, 'peer') // earlier timestamp + + const proposals = { + [localWinner.block.hash]: localWinner, + [peerWinner.block.hash]: peerWinner + } + + const all = Object.values(proposals) + all.sort((a, b) => { + if (a.block.timestamp !== b.block.timestamp) + return a.block.timestamp - b.block.timestamp + return a.block.hash < b.block.hash ? -1 : 1 + }) + + assert.strictEqual(all[0].block.hash, peerWinner.block.hash, 'anti-fork should pick peer winner with earlier timestamp') + console.log('PASS: anti-fork proposal collection') +} + +// Test 11: Quorum threshold calculation +{ + function getQuorumThreshold(leaderCount) { + return Math.ceil(leaderCount * 2 / 3) + } + assert.strictEqual(getQuorumThreshold(1), 1, '1 leader: quorum 1') + assert.strictEqual(getQuorumThreshold(3), 2, '3 leaders: quorum 2') + assert.strictEqual(getQuorumThreshold(4), 3, '4 leaders: quorum 3') + assert.strictEqual(getQuorumThreshold(5), 4, '5 leaders: quorum 4') + assert.strictEqual(getQuorumThreshold(7), 5, '7 leaders: quorum 5') + assert.strictEqual(getQuorumThreshold(10), 7, '10 leaders: quorum 7') + console.log('PASS: quorum threshold calculation') +} + +// Test 12: Quorum reached with unanimous respondents +{ + const quorumThreshold = 5 // 7 leaders + const respondents = { a: 'X', b: 'X', c: 'X', d: 'X', e: 'X' } + const hashVotes = {} + for (const hash of Object.values(respondents)) + hashVotes[hash] = (hashVotes[hash] || 0) + 1 + const bestHash = Object.keys(hashVotes).reduce((a, b) => hashVotes[a] > hashVotes[b] ? a : b) + assert.strictEqual(bestHash, 'X') + assert.strictEqual(hashVotes['X'], 5) + assert.strictEqual(hashVotes['X'] >= quorumThreshold, true) + console.log('PASS: unanimous quorum reached') +} + +// Test 13: Quorum not reached (not enough respondents) +{ + const quorumThreshold = 5 + const respondents = { a: 'X', b: 'X', c: 'X' } + const hashVotes = {} + for (const hash of Object.values(respondents)) + hashVotes[hash] = (hashVotes[hash] || 0) + 1 + const bestVotes = Object.values(hashVotes).reduce((max, v) => Math.max(max, v), 0) + assert.strictEqual(bestVotes, 3) + assert.strictEqual(bestVotes >= quorumThreshold, false) + console.log('PASS: quorum not reached (few respondents)') +} + +// Test 14: Quorum reached with majority (some dissenters) +{ + const quorumThreshold = 5 + const respondents = { a: 'X', b: 'X', c: 'X', d: 'X', e: 'X', f: 'Y', g: 'Y' } + const hashVotes = {} + for (const hash of Object.values(respondents)) + hashVotes[hash] = (hashVotes[hash] || 0) + 1 + const bestHash = Object.keys(hashVotes).reduce((a, b) => hashVotes[a] > hashVotes[b] ? a : b) + assert.strictEqual(bestHash, 'X') + assert.strictEqual(hashVotes['X'], 5) + assert.strictEqual(hashVotes['X'] >= quorumThreshold, true) + assert.strictEqual(hashVotes['Y'] >= quorumThreshold, false) + console.log('PASS: quorum reached with majority') +} + +// Test 15: Split vote — no hash reaches quorum (dangerous case) +{ + const quorumThreshold = 5 + const respondents = { a: 'X', b: 'X', c: 'X', d: 'Y', e: 'Y', f: 'Z' } + const hashVotes = {} + for (const hash of Object.values(respondents)) + hashVotes[hash] = (hashVotes[hash] || 0) + 1 + const bestVotes = Math.max(...Object.values(hashVotes)) + assert.strictEqual(bestVotes, 3) + assert.strictEqual(bestVotes >= quorumThreshold, false) + assert.strictEqual(Object.keys(hashVotes).length, 3, '3 conflicting hashes') + console.log('PASS: split vote detected (no quorum)') +} + +// Test 16: Respondents from non-leaders are ignored +{ + const activeLeaders = ['leader1', 'leader2', 'leader3'] + function isActiveLeader(name) { return activeLeaders.includes(name) } + + const respondents = {} + const rawResponses = [ + ['leader1', 'X'], ['leader2', 'X'], ['leader3', 'Y'], + ['attacker', 'X'], ['random', 'Z'] + ] + for (const [name, hash] of rawResponses) { + if (isActiveLeader(name)) + respondents[name] = hash + } + + assert.strictEqual(Object.keys(respondents).length, 3, 'only active leaders counted') + assert.strictEqual(respondents['attacker'], undefined, 'non-leader ignored') + console.log('PASS: non-leader respondents filtered') +} + +// Test 17: Backoff delays sequence +{ + const backoff = [600, 1200, 2400, 4800] + assert.strictEqual(backoff.length, 4, '4 attempts total') + let totalMax = 0 + for (let i = 0; i < backoff.length; i++) { + totalMax += backoff[i] + const expected = 600 * Math.pow(2, i) + assert.strictEqual(backoff[i], expected, 'backoff[' + i + '] = ' + expected) + } + assert.strictEqual(totalMax, 9000, 'max total wait 9s before fallback') + console.log('PASS: backoff delays') +} + +// Test 18: Anti-fork — picks hash with most votes when quorum reached +{ + const blocks = { + 'X': { block: { hash: 'X', timestamp: 1000, _id: 100, miner: 'minerX' } }, + 'Y': { block: { hash: 'Y', timestamp: 2000, _id: 100, miner: 'minerY' } } + } + const respondents = { a: 'X', b: 'X', c: 'X', d: 'Y', e: 'Y' } + const hashVotes = {} + for (const hash of Object.values(respondents)) + hashVotes[hash] = (hashVotes[hash] || 0) + 1 + const bestHash = Object.keys(hashVotes).reduce((a, b) => hashVotes[a] > hashVotes[b] ? a : b) + const winner = blocks[bestHash] + assert.strictEqual(winner.block.hash, 'X') + assert.strictEqual(hashVotes['X'], 3) + assert.strictEqual(hashVotes['Y'], 2) + console.log('PASS: anti-fork picks majority hash') +} + +// Test 19: Fallback disabled — halt instead of force finalize +{ + const config = { forceFinalizeFallback: false } + const quorumThreshold = 5 // 7 leaders, only 3 responded + const respondents = { a: 'X', b: 'X', c: 'Y' } + const hashVotes = {} + for (const hash of Object.values(respondents)) + hashVotes[hash] = (hashVotes[hash] || 0) + 1 + const bestVotes = Math.max(...Object.values(hashVotes)) + const hasQuorum = bestVotes >= quorumThreshold + assert.strictEqual(hasQuorum, false, 'should not have quorum') + // If fallback is disabled, we should NOT proceed to finalize + const shouldHalt = !config.forceFinalizeFallback && !hasQuorum + assert.strictEqual(shouldHalt, true, 'should halt when fallback disabled and no quorum') + console.log('PASS: fallback disabled halts correctly') +} + +// Test 20: Fallback enabled — finalize even without quorum +{ + const config = { forceFinalizeFallback: true } + const candidates = [makeBlock(100, 1000, 'a')] + const sorted = deterministicSort(candidates) + assert.strictEqual(sorted[0].block.hash, candidates[0].block.hash, 'should still pick winner') + assert.strictEqual(config.forceFinalizeFallback, true, 'fallback enabled') + console.log('PASS: fallback enabled allows finalization without quorum') +} + +// Test 21: Deterministic tiebreaker when votes tied +{ + const respondents = { a: 'X', b: 'X', c: 'Y', d: 'Y' } + const blockMap = { + 'X': { block: { hash: 'X', timestamp: 1000, _id: 100, miner: 'a' } }, + 'Y': { block: { hash: 'Y', timestamp: 2000, _id: 100, miner: 'b' } } + } + const hashVotes = {} + for (const hash of Object.values(respondents)) + hashVotes[hash] = (hashVotes[hash] || 0) + 1 + const tiedHashes = Object.keys(hashVotes).filter(h => hashVotes[h] === Math.max(...Object.values(hashVotes))) + // When tied, fall back to deterministic sort (earliest timestamp → lowest hash) + const sorted = tiedHashes.map(h => blockMap[h]).sort((a, b) => { + if (a.block.timestamp !== b.block.timestamp) + return a.block.timestamp - b.block.timestamp + return a.block.hash < b.block.hash ? -1 : 1 + }) + assert.strictEqual(sorted[0].block.hash, 'X', 'earliest timestamp wins tied vote') + console.log('PASS: tiebreaker falls back to deterministic sort when votes tied') +} + +console.log('\nAll tests passed!') diff --git a/test/image-sharp.js b/test/image-sharp.js new file mode 100644 index 0000000..145eb65 --- /dev/null +++ b/test/image-sharp.js @@ -0,0 +1,94 @@ +'use strict'; + +// Functional test for the image resize path against the installed `sharp`. +// It reproduces resizeImage() from src/http/image/index.js verbatim, so a +// sharp bump that breaks the API/config used there fails here. +// +// Run with: node test/image-sharp.js + +const assert = require('node:assert/strict'); +const sharp = require('sharp'); + +const MAX_INPUT_PIXELS = 20 * 1000 * 1000; +const QUALITY = 95; + +// --- exact copy of src/http/image/index.js:resizeImage ------------------- +function resizeImage(buf, width, height) { + return new Promise((rs, rj) => { + sharp(buf, { limitInputPixels: MAX_INPUT_PIXELS, failOn: 'error' }) + .resize(width, height) + .toFormat('png', { quality: QUALITY }) + .toBuffer((err, data) => { + if (err) return rj(err) + rs(data) + }) + }) +} + +const PNG_MAGIC = Buffer.from([0x89, 0x50, 0x4e, 0x47]); +let passed = 0; +let failed = 0; + +async function test(name, fn) { + try { + await fn(); + passed++; + console.log(' PASS:', name); + } catch (err) { + failed++; + console.log(' FAIL:', name, '->', err.message); + } +} + +async function main() { + console.log(`sharp ${sharp.versions.sharp} | libvips ${sharp.versions.vips} | node ${process.versions.node}\n`); + + const source = await sharp({ + create: { width: 300, height: 200, channels: 3, background: { r: 200, g: 40, b: 90 } }, + }).png().toBuffer(); + + const inputs = [ + ['png', source], + ['jpeg', await sharp(source).jpeg().toBuffer()], + ['webp', await sharp(source).webp().toBuffer()], + ['gif', await sharp(source).gif().toBuffer()], + ['tiff', await sharp(source).tiff().toBuffer()], + ]; + + for (const [fmt, buf] of inputs) { + await test(`avatar resize ${fmt} -> png 64x64 (callback API)`, async () => { + const out = await resizeImage(buf, 64, 64); + assert.ok(out.subarray(0, 4).equals(PNG_MAGIC), 'output must be a PNG'); + const meta = await sharp(out).metadata(); + assert.equal(meta.format, 'png', 'format'); + assert.equal(meta.width, 64, 'width'); + assert.equal(meta.height, 64, 'height'); + }); + } + + await test('cover resize 2048x512 stays within bounds', async () => { + const out = await resizeImage(source, 2048, 512); + const meta = await sharp(out).metadata(); + assert.equal(meta.format, 'png'); + assert.ok(meta.width <= 2048 && meta.height <= 512, `${meta.width}x${meta.height}`); + }); + + await test('limitInputPixels guard rejects oversized input', async () => { + const big = await sharp({ + create: { width: 5000, height: 5000, channels: 3, background: 'white' }, + }).png().toBuffer(); + await assert.rejects(() => resizeImage(big, 64, 64), /pixel limit|exceeds/i); + }); + + await test('garbage input rejects without crashing', async () => { + await assert.rejects(() => resizeImage(Buffer.from('not an image'), 64, 64)); + }); + + console.log(`\n=== Results: ${passed} passed, ${failed} failed ===`); + if (failed) process.exit(1); +} + +main().catch((err) => { + console.error('FATAL', err); + process.exit(1); +});

◆ Authentication Required

Commit graph

Lines changed per day

Changes per branch