@vtechcom/hexcore 2.0.0-beta.1

package/node_modules/@hexcore/shared/dist/cjs/naming.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Deterministic naming + path conventions.
+ *
+ * v1 derived container names from the DB primary key of the node, which meant
+ * you could not tell which head a container belonged to without a DB lookup,
+ * and recreating a head produced unpredictable names. v2 names everything from
+ * (headId, nodeIndex) so the whole layout is reproducible and greppable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PORTS_PER_NODE = exports.PORT_BASE = exports.containerHeadPaths = exports.CONTAINER_DATA_DIR = exports.headPaths = exports.LABEL_INSTALL = exports.LABEL_NODE_INDEX = exports.LABEL_NODE_ID = exports.LABEL_HEAD_ID = exports.LABEL_MANAGED = exports.DOCKER_NETWORK = exports.CONTAINER_PREFIX = void 0;
+exports.nodeContainerName = nodeContainerName;
+exports.headDirName = headDirName;
+exports.portsForSlot = portsForSlot;
+exports.CONTAINER_PREFIX = 'hexcore';
+exports.DOCKER_NETWORK = 'hexcore-net';
+exports.LABEL_MANAGED = 'io.hexcore.managed';
+exports.LABEL_HEAD_ID = 'io.hexcore.head-id';
+exports.LABEL_NODE_ID = 'io.hexcore.node-id';
+exports.LABEL_NODE_INDEX = 'io.hexcore.node-index';
+/**
+ * Which Hexcore installation owns this container.
+ *
+ * `LABEL_MANAGED` says "Hexcore made this" and nothing more, so it cannot tell
+ * two installations apart — and more than one is normal: a developer running
+ * the repo has one state dir, an `npm i -g hexcore` on the same machine has
+ * another, and both talk to the same Docker daemon. A bulk operation matched on
+ * `LABEL_MANAGED` alone therefore reaches across installations, which is how
+ * `hexcore clean` destroyed the containers of a head it had never heard of.
+ *
+ * The value is a random id kept in the state dir, so it identifies the state
+ * dir rather than the machine, the user or the checkout.
+ */
+exports.LABEL_INSTALL = 'io.hexcore.install';
+/** e.g. head 3, index 0 -> `hexcore-h3-n0` (also the Hydra --node-id and DNS name). */
+function nodeContainerName(headId, nodeIndex) {
+    return `${exports.CONTAINER_PREFIX}-h${headId}-n${nodeIndex}`;
+}
+function headDirName(headId) {
+    return `head-${headId}`;
+}
+/** Layout under the state dir: heads/head-1/{keys,persistence,...} */
+const headPaths = (stateDir, headId) => {
+    const root = `${trimSlash(stateDir)}/heads/${headDirName(headId)}`;
+    return {
+        root,
+        keys: `${root}/keys`,
+        persistence: `${root}/persistence`,
+        protocolParameters: `${root}/protocol-parameters.json`,
+        /**
+         * Offline mode only. `--initial-utxo` is the L2 ledger's entire
+         * starting state and `--ledger-genesis` the simulated L1's block-time
+         * parameters; both are written at start, next to everything else the
+         * head owns, so deleting the head takes them with it.
+         */
+        initialUtxo: `${root}/initial-utxo.json`,
+        ledgerGenesis: `${root}/shelley-genesis.json`,
+        /**
+         * Written by v2 up to the per-node keys change, and still removed on
+         * every start so a stale project id does not sit on disk unused.
+         */
+        legacyBlockfrostToken: `${root}/blockfrost.txt`,
+        /**
+         * One token file per node: hydra-node takes `--blockfrost FILE`, so a
+         * per-node key can only be expressed as a per-node file. Nodes sharing
+         * a key simply get the same contents written to each of theirs.
+         */
+        nodeBlockfrostToken: (nodeIndex) => `${root}/blockfrost-n${nodeIndex}.txt`,
+        nodePersistence: (nodeIndex) => `${root}/persistence/n${nodeIndex}`,
+        nodeKeys: (nodeIndex) => ({
+            hydraSk: `${root}/keys/n${nodeIndex}.hydra.sk`,
+            hydraVk: `${root}/keys/n${nodeIndex}.hydra.vk`,
+            cardanoSk: `${root}/keys/n${nodeIndex}.cardano.sk`,
+            cardanoVk: `${root}/keys/n${nodeIndex}.cardano.vk`,
+        }),
+    };
+};
+exports.headPaths = headPaths;
+/**
+ * Same layout as seen from inside the container, where the state dir is always
+ * bind-mounted at /data. Keeping the two in lockstep avoids the class of bug
+ * where a host path leaks into a container argument.
+ */
+exports.CONTAINER_DATA_DIR = '/data';
+const containerHeadPaths = (headId) => (0, exports.headPaths)(exports.CONTAINER_DATA_DIR, headId);
+exports.containerHeadPaths = containerHeadPaths;
+function trimSlash(p) {
+    return p.replace(/\/+$/, '');
+}
+/**
+ * Port allocation. Each node gets a contiguous triple so a head of N nodes
+ * occupies a predictable, non-overlapping range:
+ *   api        = base + slot*10
+ *   p2p        = base + slot*10 + 1
+ *   monitoring = base + slot*10 + 2
+ */
+exports.PORT_BASE = 14000;
+exports.PORTS_PER_NODE = 10;
+function portsForSlot(slot, base = exports.PORT_BASE) {
+    const start = base + slot * exports.PORTS_PER_NODE;
+    return { api: start, p2p: start + 1, monitoring: start + 2 };
+}
+//# sourceMappingURL=naming.js.map

package/node_modules/@hexcore/shared/dist/cjs/naming.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming.js","sourceRoot":"","sources":["../../src/naming.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAyBH,8CAEC;AAED,kCAEC;AAmED,oCAGC;AAnGY,QAAA,gBAAgB,GAAG,SAAS,CAAC;AAC7B,QAAA,cAAc,GAAG,aAAa,CAAC;AAE/B,QAAA,aAAa,GAAG,oBAAoB,CAAC;AACrC,QAAA,aAAa,GAAG,oBAAoB,CAAC;AACrC,QAAA,aAAa,GAAG,oBAAoB,CAAC;AACrC,QAAA,gBAAgB,GAAG,uBAAuB,CAAC;AACxD;;;;;;;;;;;;GAYG;AACU,QAAA,aAAa,GAAG,oBAAoB,CAAC;AAElD,uFAAuF;AACvF,SAAgB,iBAAiB,CAAC,MAAc,EAAE,SAAiB;IAC/D,OAAO,GAAG,wBAAgB,KAAK,MAAM,KAAK,SAAS,EAAE,CAAC;AAC1D,CAAC;AAED,SAAgB,WAAW,CAAC,MAAc;IACtC,OAAO,QAAQ,MAAM,EAAE,CAAC;AAC5B,CAAC;AAED,sEAAsE;AAC/D,MAAM,SAAS,GAAG,CAAC,QAAgB,EAAE,MAAc,EAAE,EAAE;IAC1D,MAAM,IAAI,GAAG,GAAG,SAAS,CAAC,QAAQ,CAAC,UAAU,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC;IACnE,OAAO;QACH,IAAI;QACJ,IAAI,EAAE,GAAG,IAAI,OAAO;QACpB,WAAW,EAAE,GAAG,IAAI,cAAc;QAClC,kBAAkB,EAAE,GAAG,IAAI,2BAA2B;QACtD;;;;;WAKG;QACH,WAAW,EAAE,GAAG,IAAI,oBAAoB;QACxC,aAAa,EAAE,GAAG,IAAI,uBAAuB;QAC7C;;;WAGG;QACH,qBAAqB,EAAE,GAAG,IAAI,iBAAiB;QAC/C;;;;WAIG;QACH,mBAAmB,EAAE,CAAC,SAAiB,EAAE,EAAE,CAAC,GAAG,IAAI,gBAAgB,SAAS,MAAM;QAClF,eAAe,EAAE,CAAC,SAAiB,EAAE,EAAE,CAAC,GAAG,IAAI,iBAAiB,SAAS,EAAE;QAC3E,QAAQ,EAAE,CAAC,SAAiB,EAAE,EAAE,CAAC,CAAC;YAC9B,OAAO,EAAE,GAAG,IAAI,UAAU,SAAS,WAAW;YAC9C,OAAO,EAAE,GAAG,IAAI,UAAU,SAAS,WAAW;YAC9C,SAAS,EAAE,GAAG,IAAI,UAAU,SAAS,aAAa;YAClD,SAAS,EAAE,GAAG,IAAI,UAAU,SAAS,aAAa;SACrD,CAAC;KACL,CAAC;AACN,CAAC,CAAC;AAlCW,QAAA,SAAS,aAkCpB;AAEF;;;;GAIG;AACU,QAAA,kBAAkB,GAAG,OAAO,CAAC;AACnC,MAAM,kBAAkB,GAAG,CAAC,MAAc,EAAE,EAAE,CAAC,IAAA,iBAAS,EAAC,0BAAkB,EAAE,MAAM,CAAC,CAAC;AAA/E,QAAA,kBAAkB,sBAA6D;AAE5F,SAAS,SAAS,CAAC,CAAS;IACxB,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AACjC,CAAC;AAED;;;;;;GAMG;AACU,QAAA,SAAS,GAAG,KAAK,CAAC;AAClB,QAAA,cAAc,GAAG,EAAE,CAAC;AAQjC,SAAgB,YAAY,CAAC,IAAY,EAAE,IAAI,GAAG,iBAAS;IACvD,MAAM,KAAK,GAAG,IAAI,GAAG,IAAI,GAAG,sBAAc,CAAC;IAC3C,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,EAAE,UAAU,EAAE,KAAK,GAAG,CAAC,EAAE,CAAC;AACjE,CAAC"}

package/node_modules/@hexcore/shared/dist/cjs/offline.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Offline mode.
+ *
+ * hydra-node can run with its layer-1 interface disabled entirely: no chain to
+ * observe, no scripts to publish, no funds to commit. The head opens
+ * immediately with a UTxO set handed to it on disk, which makes it the fastest
+ * way to develop against the Hydra API — and the only way to run one without a
+ * Blockfrost key or a cardano-node socket.
+ *
+ * The flags are mutually exclusive with the online ones (`--offline-head-seed`
+ * is a different branch of hydra-node's option parser than
+ * `--mainnet`/`--node-socket`/`--blockfrost`), so an offline head is a distinct
+ * chain backend here rather than a checkbox on an online one. Passing an online
+ * flag alongside `--offline-head-seed` aborts option parsing and the container
+ * dies before it logs anything useful.
+ *
+ * Reference layout this mirrors: infra/preprod-offline in the graveyard repo —
+ * `--offline-head-seed` + `--initial-utxo` + `--ledger-genesis`, no
+ * contestation or deposit period, single node.
+ */
+/** `--offline-head-seed` takes 32 bytes as hex. */
+export declare const OFFLINE_HEAD_SEED_BYTES = 32;
+/**
+ * How many nodes an offline head may run.
+ *
+ * Offline mode is multi-party: `--peer` and `--hydra-verification-key` sit
+ * outside hydra-node's chain-config group, so the nodes form a Head over the
+ * same network layer an online head uses. Only the Cardano key options are
+ * online-only, and offline peers authorise nothing on chain, so they are simply
+ * not passed.
+ *
+ * The cap is lower than an online head's ten because every node runs on this
+ * one machine with no L1 to spread the load over, and each brings an embedded
+ * etcd. Five is enough for the multi-party flows worth rehearsing offline
+ * without turning a laptop into the bottleneck under test.
+ */
+export declare const MAX_OFFLINE_NODES = 5;
+/** Lovelace seeded to each node's own address when no UTxO file is supplied. */
+export declare const DEFAULT_OFFLINE_SEED_LOVELACE = 20000000000;
+/** A hex seed is exactly 32 bytes, lowercase or upper. */
+export declare const offlineHeadSeedPattern: RegExp;
+/**
+ * Seed derived from the head id when the operator names none.
+ *
+ * It only has to be stable and unique per head: hydra-node derives the offline
+ * head id from it, and every node of the same head must agree. Deriving it from
+ * the row id gives both properties for free and keeps two offline heads on one
+ * machine from colliding — which they would if everyone kept the `…0001` from
+ * the reference config.
+ */
+export declare function defaultOfflineHeadSeed(headId: number): string;
+export interface OfflineUtxoEntry {
+    address: string;
+    /**
+     * Plain number, not a string: the file is JSON that hydra-node reads as
+     * JSON, so the value has to survive as a number anyway. The schema bounds
+     * it below Number.MAX_SAFE_INTEGER — well above any seed worth using, and
+     * far enough from Cardano's 45e15 total supply that no rounding is possible.
+     */
+    lovelace: number;
+}
+/**
+ * The `--initial-utxo` file: the L2 ledger's entire starting state.
+ *
+ * Keys are TxIn references that no L1 transaction produced — offline mode never
+ * checks them against a chain. A zero tx id with one output index per node is
+ * what the reference config uses, and it keeps the file readable.
+ *
+ * Addresses are the nodes' own generated (or imported) Cardano addresses, so
+ * the operator already holds the signing keys for everything in the head.
+ */
+export declare function buildInitialUtxo(entries: OfflineUtxoEntry[]): Record<string, unknown>;
+//# sourceMappingURL=offline.d.ts.map

package/node_modules/@hexcore/shared/dist/cjs/offline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offline.d.ts","sourceRoot":"","sources":["../../src/offline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,mDAAmD;AACnD,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,IAAI,CAAC;AAEnC,gFAAgF;AAChF,eAAO,MAAM,6BAA6B,cAAiB,CAAC;AAE5D,0DAA0D;AAC1D,eAAO,MAAM,sBAAsB,QAAsB,CAAC;AAE1D;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUrF"}

package/node_modules/@hexcore/shared/dist/cjs/offline.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Offline mode.
+ *
+ * hydra-node can run with its layer-1 interface disabled entirely: no chain to
+ * observe, no scripts to publish, no funds to commit. The head opens
+ * immediately with a UTxO set handed to it on disk, which makes it the fastest
+ * way to develop against the Hydra API — and the only way to run one without a
+ * Blockfrost key or a cardano-node socket.
+ *
+ * The flags are mutually exclusive with the online ones (`--offline-head-seed`
+ * is a different branch of hydra-node's option parser than
+ * `--mainnet`/`--node-socket`/`--blockfrost`), so an offline head is a distinct
+ * chain backend here rather than a checkbox on an online one. Passing an online
+ * flag alongside `--offline-head-seed` aborts option parsing and the container
+ * dies before it logs anything useful.
+ *
+ * Reference layout this mirrors: infra/preprod-offline in the graveyard repo —
+ * `--offline-head-seed` + `--initial-utxo` + `--ledger-genesis`, no
+ * contestation or deposit period, single node.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.offlineHeadSeedPattern = exports.DEFAULT_OFFLINE_SEED_LOVELACE = exports.MAX_OFFLINE_NODES = exports.OFFLINE_HEAD_SEED_BYTES = void 0;
+exports.defaultOfflineHeadSeed = defaultOfflineHeadSeed;
+exports.buildInitialUtxo = buildInitialUtxo;
+/** `--offline-head-seed` takes 32 bytes as hex. */
+exports.OFFLINE_HEAD_SEED_BYTES = 32;
+/**
+ * How many nodes an offline head may run.
+ *
+ * Offline mode is multi-party: `--peer` and `--hydra-verification-key` sit
+ * outside hydra-node's chain-config group, so the nodes form a Head over the
+ * same network layer an online head uses. Only the Cardano key options are
+ * online-only, and offline peers authorise nothing on chain, so they are simply
+ * not passed.
+ *
+ * The cap is lower than an online head's ten because every node runs on this
+ * one machine with no L1 to spread the load over, and each brings an embedded
+ * etcd. Five is enough for the multi-party flows worth rehearsing offline
+ * without turning a laptop into the bottleneck under test.
+ */
+exports.MAX_OFFLINE_NODES = 5;
+/** Lovelace seeded to each node's own address when no UTxO file is supplied. */
+exports.DEFAULT_OFFLINE_SEED_LOVELACE = 20_000_000_000;
+/** A hex seed is exactly 32 bytes, lowercase or upper. */
+exports.offlineHeadSeedPattern = /^[0-9a-fA-F]{64}$/;
+/**
+ * Seed derived from the head id when the operator names none.
+ *
+ * It only has to be stable and unique per head: hydra-node derives the offline
+ * head id from it, and every node of the same head must agree. Deriving it from
+ * the row id gives both properties for free and keeps two offline heads on one
+ * machine from colliding — which they would if everyone kept the `…0001` from
+ * the reference config.
+ */
+function defaultOfflineHeadSeed(headId) {
+    return headId.toString(16).padStart(exports.OFFLINE_HEAD_SEED_BYTES * 2, '0');
+}
+/**
+ * The `--initial-utxo` file: the L2 ledger's entire starting state.
+ *
+ * Keys are TxIn references that no L1 transaction produced — offline mode never
+ * checks them against a chain. A zero tx id with one output index per node is
+ * what the reference config uses, and it keeps the file readable.
+ *
+ * Addresses are the nodes' own generated (or imported) Cardano addresses, so
+ * the operator already holds the signing keys for everything in the head.
+ */
+function buildInitialUtxo(entries) {
+    const txId = '0'.repeat(64);
+    const utxo = {};
+    entries.forEach((entry, index) => {
+        utxo[`${txId}#${index}`] = {
+            address: entry.address,
+            value: { lovelace: entry.lovelace },
+        };
+    });
+    return utxo;
+}
+//# sourceMappingURL=offline.js.map

package/node_modules/@hexcore/shared/dist/cjs/offline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"offline.js","sourceRoot":"","sources":["../../src/offline.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;GAmBG;;;AAoCH,wDAEC;AAuBD,4CAUC;AArED,mDAAmD;AACtC,QAAA,uBAAuB,GAAG,EAAE,CAAC;AAE1C;;;;;;;;;;;;;GAaG;AACU,QAAA,iBAAiB,GAAG,CAAC,CAAC;AAEnC,gFAAgF;AACnE,QAAA,6BAA6B,GAAG,cAAc,CAAC;AAE5D,0DAA0D;AAC7C,QAAA,sBAAsB,GAAG,mBAAmB,CAAC;AAE1D;;;;;;;;GAQG;AACH,SAAgB,sBAAsB,CAAC,MAAc;IACjD,OAAO,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,+BAAuB,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;AAC1E,CAAC;AAaD;;;;;;;;;GASG;AACH,SAAgB,gBAAgB,CAAC,OAA2B;IACxD,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IAC5B,MAAM,IAAI,GAA4B,EAAE,CAAC;IACzC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;QAC7B,IAAI,CAAC,GAAG,IAAI,IAAI,KAAK,EAAE,CAAC,GAAG;YACvB,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,KAAK,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE;SACtC,CAAC;IACN,CAAC,CAAC,CAAC;IACH,OAAO,IAAI,CAAC;AAChB,CAAC"}

package/node_modules/@hexcore/shared/dist/cjs/protocol-params.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Editing the L2 ledger's protocol parameters.
+ *
+ * A Head runs its own ledger, and `--ledger-protocol-parameters` is the file
+ * that bounds it: transaction size, execution units, fees. Up to now the
+ * control-plane fetched those from the chain and the only way to change one was
+ * to POST a raw `protocolParameters` object no UI ever produced.
+ *
+ * Two things make hand-editing that object hazardous, and both are why this
+ * module exists rather than a plain textarea:
+ *
+ *  1. **Overrides merge at the TOP level only** (`{...fetched, ...overrides}`).
+ *     Sending `{maxTxExecutionUnits: {memory: 20000000}}` therefore does not
+ *     raise the memory budget — it replaces the whole object and drops `steps`,
+ *     and hydra-node then fails to decode its own ledger config. Every editable
+ *     field here declares the top-level key it belongs to, and `writeParam`
+ *     rewrites that key whole.
+ *  2. **What is worth pinning is a small subset.** Overriding a value that the
+ *     chain later changes at a hard fork silently freezes this head on the old
+ *     one, so the UI diffs against a freshly fetched baseline and stores only
+ *     what the operator actually moved.
+ */
+/**
+ * Major protocol version of the current Cardano era.
+ *
+ * Bumped to 11 by the Plomin-line hard fork. It matters here because
+ * hydra-node's ledger refuses a transaction built for an era it does not
+ * recognise, so a baseline still claiming 10 makes every L2 transaction fail
+ * with an era mismatch that points nowhere near this file. Live parameters come
+ * from the chain and carry the real number; this is only the fallback used when
+ * nothing can be fetched.
+ */
+export declare const CURRENT_PROTOCOL_MAJOR = 11;
+export type ProtocolParamGroup = 'limits' | 'plutus' | 'fees' | 'version';
+export interface ProtocolParamField {
+    /** Dot path into the parameters object, e.g. `maxTxExecutionUnits.memory`. */
+    path: string;
+    label: string;
+    group: ProtocolParamGroup;
+    /** Integers are sent as integers; a decimal field keeps its fractional part. */
+    kind: 'integer' | 'decimal';
+    hint: string;
+    /**
+     * True for the fields `applyL2Defaults` zeroes on purpose — a Head is not a
+     * chain, so it charges no fees and holds no deposits. Editing one is
+     * allowed (a head that wants realistic fee accounting is a real use case),
+     * but the UI says what the zero was for.
+     */
+    l2Zeroed?: boolean;
+}
+/**
+ * The parameters worth exposing, in the order they are shown.
+ *
+ * Deliberately not the full set: cost models are 200-element arrays, the voting
+ * thresholds and treasury knobs are governance-only and mean nothing inside a
+ * Head. Anything absent is still reachable through the raw JSON escape hatch.
+ */
+export declare const PROTOCOL_PARAM_FIELDS: readonly ProtocolParamField[];
+export declare const PROTOCOL_PARAM_GROUP_LABELS: Record<ProtocolParamGroup, string>;
+/** Value at a dot path, or undefined when any segment is missing. */
+export declare function readParam(params: Record<string, unknown>, path: string): unknown;
+/**
+ * Set a dot path, cloning every object along the way.
+ *
+ * Cloning is what makes the diff below trustworthy: mutating the fetched
+ * baseline in place would make it equal to the edit, and the change would then
+ * be dropped as "unchanged" instead of being sent as an override.
+ */
+export declare function writeParam(params: Record<string, unknown>, path: string, value: unknown): Record<string, unknown>;
+/**
+ * Top-level keys whose value differs from the baseline.
+ *
+ * Whole keys, never partial objects — see the merge caveat at the top of this
+ * file. Comparison is by serialised value, which is exact for the numbers,
+ * small objects and arrays protocol parameters are made of, and cheap enough
+ * for the ~30 keys involved.
+ */
+export declare function diffProtocolParameters(baseline: Record<string, unknown>, edited: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=protocol-params.d.ts.map

package/node_modules/@hexcore/shared/dist/cjs/protocol-params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol-params.d.ts","sourceRoot":"","sources":["../../src/protocol-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;AAE1E,MAAM,WAAW,kBAAkB;IAC/B,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,kBAAkB,CAAC;IAC1B,gFAAgF;IAChF,IAAI,EAAE,SAAS,GAAG,SAAS,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,EAAE,SAAS,kBAAkB,EA8H9D,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAK1E,CAAC;AAEF,qEAAqE;AACrE,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAOhF;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQjH;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAClC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAMzB"}

package/node_modules/@hexcore/shared/dist/cjs/protocol-params.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * Editing the L2 ledger's protocol parameters.
+ *
+ * A Head runs its own ledger, and `--ledger-protocol-parameters` is the file
+ * that bounds it: transaction size, execution units, fees. Up to now the
+ * control-plane fetched those from the chain and the only way to change one was
+ * to POST a raw `protocolParameters` object no UI ever produced.
+ *
+ * Two things make hand-editing that object hazardous, and both are why this
+ * module exists rather than a plain textarea:
+ *
+ *  1. **Overrides merge at the TOP level only** (`{...fetched, ...overrides}`).
+ *     Sending `{maxTxExecutionUnits: {memory: 20000000}}` therefore does not
+ *     raise the memory budget — it replaces the whole object and drops `steps`,
+ *     and hydra-node then fails to decode its own ledger config. Every editable
+ *     field here declares the top-level key it belongs to, and `writeParam`
+ *     rewrites that key whole.
+ *  2. **What is worth pinning is a small subset.** Overriding a value that the
+ *     chain later changes at a hard fork silently freezes this head on the old
+ *     one, so the UI diffs against a freshly fetched baseline and stores only
+ *     what the operator actually moved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROTOCOL_PARAM_GROUP_LABELS = exports.PROTOCOL_PARAM_FIELDS = exports.CURRENT_PROTOCOL_MAJOR = void 0;
+exports.readParam = readParam;
+exports.writeParam = writeParam;
+exports.diffProtocolParameters = diffProtocolParameters;
+/**
+ * Major protocol version of the current Cardano era.
+ *
+ * Bumped to 11 by the Plomin-line hard fork. It matters here because
+ * hydra-node's ledger refuses a transaction built for an era it does not
+ * recognise, so a baseline still claiming 10 makes every L2 transaction fail
+ * with an era mismatch that points nowhere near this file. Live parameters come
+ * from the chain and carry the real number; this is only the fallback used when
+ * nothing can be fetched.
+ */
+exports.CURRENT_PROTOCOL_MAJOR = 11;
+/**
+ * The parameters worth exposing, in the order they are shown.
+ *
+ * Deliberately not the full set: cost models are 200-element arrays, the voting
+ * thresholds and treasury knobs are governance-only and mean nothing inside a
+ * Head. Anything absent is still reachable through the raw JSON escape hatch.
+ */
+exports.PROTOCOL_PARAM_FIELDS = [
+    {
+        path: 'maxTxSize',
+        label: 'Max transaction size (bytes)',
+        group: 'limits',
+        kind: 'integer',
+        hint: 'Largest L2 transaction the head will accept. Raising it is the usual fix for a batch that will not fit.',
+    },
+    {
+        path: 'maxValueSize',
+        label: 'Max value size (bytes)',
+        group: 'limits',
+        kind: 'integer',
+        hint: 'Serialised size limit of one output’s value — the ceiling on how many native assets a UTxO can carry.',
+    },
+    {
+        path: 'maxBlockBodySize',
+        label: 'Max block body size (bytes)',
+        group: 'limits',
+        kind: 'integer',
+        hint: 'Bounds a snapshot’s worth of transactions.',
+    },
+    {
+        path: 'maxCollateralInputs',
+        label: 'Max collateral inputs',
+        group: 'limits',
+        kind: 'integer',
+        hint: 'How many inputs a script transaction may pledge as collateral.',
+    },
+    {
+        path: 'collateralPercentage',
+        label: 'Collateral percentage',
+        group: 'limits',
+        kind: 'integer',
+        hint: 'Collateral required as a percentage of the fee. Meaningless while fees are zero.',
+    },
+    {
+        path: 'maxTxExecutionUnits.memory',
+        label: 'Max tx execution memory',
+        group: 'plutus',
+        kind: 'integer',
+        hint: 'Plutus memory budget for one transaction. The limit a heavy validator hits first.',
+    },
+    {
+        path: 'maxTxExecutionUnits.steps',
+        label: 'Max tx execution steps',
+        group: 'plutus',
+        kind: 'integer',
+        hint: 'Plutus CPU budget for one transaction.',
+    },
+    {
+        path: 'maxBlockExecutionUnits.memory',
+        label: 'Max block execution memory',
+        group: 'plutus',
+        kind: 'integer',
+        hint: 'Aggregate Plutus memory across a block.',
+    },
+    {
+        path: 'maxBlockExecutionUnits.steps',
+        label: 'Max block execution steps',
+        group: 'plutus',
+        kind: 'integer',
+        hint: 'Aggregate Plutus CPU across a block.',
+    },
+    {
+        path: 'executionUnitPrices.priceMemory',
+        label: 'Price per memory unit',
+        group: 'plutus',
+        kind: 'decimal',
+        // Deliberately NOT in applyL2Defaults, so the chain's real prices are
+        // what a head gets unless someone changes them here. Setting both to 0
+        // is what makes script execution free inside the head.
+        hint: 'Converts Plutus memory into fee. Set this and the step price to 0 to make scripts free on L2.',
+    },
+    {
+        path: 'executionUnitPrices.priceSteps',
+        label: 'Price per CPU step',
+        group: 'plutus',
+        kind: 'decimal',
+        hint: 'Converts Plutus CPU into fee. Kept at the chain’s value unless you zero it.',
+    },
+    {
+        path: 'txFeeFixed',
+        label: 'Fixed fee (lovelace)',
+        group: 'fees',
+        kind: 'integer',
+        hint: 'Flat part of the fee. Zeroed on L2 — a head that charges fees needs somewhere for them to go.',
+        l2Zeroed: true,
+    },
+    {
+        path: 'txFeePerByte',
+        label: 'Fee per byte (lovelace)',
+        group: 'fees',
+        kind: 'integer',
+        hint: 'Size-proportional part of the fee. Zeroed on L2.',
+        l2Zeroed: true,
+    },
+    {
+        path: 'utxoCostPerByte',
+        label: 'UTxO cost per byte (lovelace)',
+        group: 'fees',
+        kind: 'integer',
+        hint: 'Min-ADA per byte of output. Zeroed on L2 so small outputs are not rejected inside the head.',
+        l2Zeroed: true,
+    },
+    {
+        path: 'minFeeRefScriptCostPerByte',
+        label: 'Reference script cost per byte',
+        group: 'fees',
+        kind: 'integer',
+        hint: 'Surcharge for reference scripts, by size.',
+    },
+    {
+        path: 'protocolVersion.major',
+        label: 'Protocol version (major)',
+        group: 'version',
+        kind: 'integer',
+        hint: `Ledger era the head validates against. ${exports.CURRENT_PROTOCOL_MAJOR} is current; lowering it rejects transactions built for the live chain.`,
+    },
+    {
+        path: 'protocolVersion.minor',
+        label: 'Protocol version (minor)',
+        group: 'version',
+        kind: 'integer',
+        hint: 'Minor version, almost always 0.',
+    },
+];
+exports.PROTOCOL_PARAM_GROUP_LABELS = {
+    limits: 'Ledger limits',
+    plutus: 'Plutus execution budgets',
+    fees: 'Fees and deposits',
+    version: 'Protocol version',
+};
+/** Value at a dot path, or undefined when any segment is missing. */
+function readParam(params, path) {
+    let cursor = params;
+    for (const segment of path.split('.')) {
+        if (cursor === null || typeof cursor !== 'object')
+            return undefined;
+        cursor = cursor[segment];
+    }
+    return cursor;
+}
+/**
+ * Set a dot path, cloning every object along the way.
+ *
+ * Cloning is what makes the diff below trustworthy: mutating the fetched
+ * baseline in place would make it equal to the edit, and the change would then
+ * be dropped as "unchanged" instead of being sent as an override.
+ */
+function writeParam(params, path, value) {
+    const [head, ...rest] = path.split('.');
+    if (head === undefined)
+        return params;
+    if (rest.length === 0)
+        return { ...params, [head]: value };
+    const child = params[head];
+    const base = child !== null && typeof child === 'object' ? child : {};
+    return { ...params, [head]: writeParam(base, rest.join('.'), value) };
+}
+/**
+ * Top-level keys whose value differs from the baseline.
+ *
+ * Whole keys, never partial objects — see the merge caveat at the top of this
+ * file. Comparison is by serialised value, which is exact for the numbers,
+ * small objects and arrays protocol parameters are made of, and cheap enough
+ * for the ~30 keys involved.
+ */
+function diffProtocolParameters(baseline, edited) {
+    const overrides = {};
+    for (const key of Object.keys(edited)) {
+        if (JSON.stringify(edited[key]) !== JSON.stringify(baseline[key]))
+            overrides[key] = edited[key];
+    }
+    return overrides;
+}
+//# sourceMappingURL=protocol-params.js.map

package/node_modules/@hexcore/shared/dist/cjs/protocol-params.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol-params.js","sourceRoot":"","sources":["../../src/protocol-params.ts"],"names":[],"mappings":"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"}