@midnight-ntwrk/midnight-js-protocol 5.0.0-beta.7 → 5.0.0-beta.8

package/dist/errors.js

@@ -0,0 +1,595 @@
+/*
+ * This file is part of midnight-js.
+ * Copyright (C) Midnight Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Stable error-code strings for this package. Every error class in this module
+ * carries one of these on its `code` field, which is the field a consumer
+ * switches on to tell one failure from another.
+ *
+ * @see {@link SharedTableDiscipline}
+ */
+const PROTOCOL_ERROR_CODES = Object.freeze({
+    UNKNOWN_PROTOCOL_VERSION_READ: 'MIDNIGHT_JS_P_UNKNOWN_PROTOCOL_VERSION_READ',
+    UNKNOWN_PROTOCOL_VERSION_CONSTRUCT: 'MIDNIGHT_JS_P_UNKNOWN_PROTOCOL_VERSION_CONSTRUCT',
+    LEDGER8_INSTANCE_MISMATCH: 'MIDNIGHT_JS_P_LEDGER8_INSTANCE_MISMATCH',
+    LEDGER8_RUNTIME_MISSING: 'MIDNIGHT_JS_P_LEDGER8_RUNTIME_MISSING',
+    DOWN_CONVERT_FAILED: 'MIDNIGHT_JS_P_DOWN_CONVERT_FAILED',
+    MERKLE_NOT_REHASHED: 'MIDNIGHT_JS_P_MERKLE_NOT_REHASHED',
+    COMPOSE_FAILED: 'MIDNIGHT_JS_P_COMPOSE_FAILED',
+    COMPOSE_OPTION_INVALID: 'MIDNIGHT_JS_P_COMPOSE_OPTION_INVALID',
+    STATE_DECODE_FAILED: 'MIDNIGHT_JS_P_STATE_DECODE_FAILED',
+    UNKNOWN_LEDGER_VERSION: 'MIDNIGHT_JS_P_UNKNOWN_LEDGER_VERSION',
+    LEDGER8_RUNTIME_INVALID: 'MIDNIGHT_JS_P_LEDGER8_RUNTIME_INVALID',
+    UNKNOWN_LEDGER8_AXIS: 'MIDNIGHT_JS_P_UNKNOWN_LEDGER8_AXIS',
+    PAYLOAD_NOT_A_TRANSACTION: 'MIDNIGHT_JS_P_PAYLOAD_NOT_A_TRANSACTION'
+});
+/**
+ * Thrown by `protocolVersionToLedger` (and, transitively, `versionOfRecord` /
+ * `networkHeadVersion`) when a raw `protocolVersion` integer cannot be
+ * resolved to a `LedgerVersion`. Those live in `./version`, which imports this
+ * module -- the dependency stays one-way, so they are named here rather than
+ * linked.
+ *
+ * `code` is the field to switch on to tell all four cases apart: it splits
+ * `reason` by the `path` that produced it.
+ *
+ * @param protocolVersion The raw `protocolVersion` value that could not be
+ *   resolved. Carried for programmatic use, and rendered in the message.
+ * @param path Which call path asked for the version — see
+ *   {@link VersionResolutionPath}.
+ * @param reason A malformed input (wrong shape or type, not a
+ *   protocol-version problem at all) or a well-formed but genuinely unknown
+ *   version (a real protocol version this framework build does not support
+ *   yet) — see {@link ProtocolVersionUnknownReason}.
+ */
+class UnknownProtocolVersionError extends Error {
+    protocolVersion;
+    path;
+    reason;
+    code;
+    constructor(protocolVersion, path, reason) {
+        super(reason === 'malformed'
+            ? `Malformed protocolVersion (expected a non-negative integer, got ${typeof protocolVersion} ` +
+                `${String(protocolVersion)}) on the ${path} path. This usually means a non-numeric, fractional, or ` +
+                `negative value reached protocolVersionToLedger — check that the source field is actually a raw ` +
+                `protocolVersion integer (e.g. from an indexer transaction/block record or ` +
+                `queryLatestProtocolVersion()), not a derived or miscoded value.`
+            : `Unknown protocolVersion ${protocolVersion} on the ${path} path. ` +
+                `Supported eras: v8 (node 1.x) and v9 (node 2.x). ` +
+                `An unknown node major usually means this framework major predates a newer fork — upgrade midnight-js.`);
+        this.protocolVersion = protocolVersion;
+        this.path = path;
+        this.reason = reason;
+        this.name = 'UnknownProtocolVersionError';
+        this.code =
+            path === 'read'
+                ? PROTOCOL_ERROR_CODES.UNKNOWN_PROTOCOL_VERSION_READ
+                : PROTOCOL_ERROR_CODES.UNKNOWN_PROTOCOL_VERSION_CONSTRUCT;
+    }
+}
+/**
+ * Thrown when a lazily-loaded subpath export carrying the retained pre-fork
+ * runtime could not be acquired at all. Raised by `loadLedger8`
+ * (`lib/v8/load.ts`) and `loadLedger8Engine` (`lib/v8/load-engine.ts`), and
+ * surfaced through `createLedger8Engine` and `loadLedgerEra('v8')`.
+ *
+ * A failed acquisition is not memoised: the next call retries the import.
+ * Distinct from {@link Ledger8RuntimeInvalidError}, which reports a runtime
+ * that WAS acquired and then handed over incomplete.
+ *
+ * @param subpath Which chunk failed to load — see {@link RetainedEraSubpath}.
+ * @param cause The underlying module-resolution or initialisation failure,
+ *   preserved unchanged. Read it for which module actually failed.
+ * @see {@link ModuleGraphAndLazyLoading}
+ * @see {@link EraSeam}
+ */
+class Ledger8RuntimeMissingError extends Error {
+    subpath;
+    code = PROTOCOL_ERROR_CODES.LEDGER8_RUNTIME_MISSING;
+    constructor(subpath, cause) {
+        super(`Failed to load the retained pre-fork runtime via the midnight-js-protocol${subpath} subpath export. ` +
+            'Read the wrapped cause for which module actually failed to resolve or initialise. This usually means ' +
+            'a broken or partial install of the protocol package — reinstall dependencies and retry.', { cause });
+        this.subpath = subpath;
+        this.name = 'Ledger8RuntimeMissingError';
+    }
+}
+/**
+ * The npm scopes this package and its retained pre-fork runtimes are published
+ * under, while the scope migration runs.
+ *
+ * Do not join a scope to the `/` in one literal -- the dual-publish rewrite
+ * would collapse both names into one. See DualInstantiationGuard.
+ */
+const PUBLISHED_SCOPES = Object.freeze(['@midnight-ntwrk', '@midnightntwrk']);
+/**
+ * The unscoped npm name of each axis; `axisPackageNames` joins every published
+ * scope onto it. See DualInstantiationGuard.
+ */
+const AXIS_BARE_PACKAGE_NAMES = Object.freeze(Object.assign(Object.create(null), {
+    'onchain-runtime-v3': 'onchain-runtime-v3'
+}));
+const axisPackageNames = (axis) => PUBLISHED_SCOPES.map((scope) => `${scope}/${AXIS_BARE_PACKAGE_NAMES[axis]}`);
+/**
+ * Thrown by `assertSharedLedger8Instance` (`lib/v8/instance-guard.ts`)
+ * when the same-named WASM package resolved to two physically distinct copies
+ * in this process (a dual-instantiation).
+ *
+ * Carries no `cause`: this is a direct reference-equality assertion failure,
+ * not a wrapped lower-level exception.
+ *
+ * @param axis Which physical-copy axis the check ran on — see
+ *   {@link Ledger8InstanceAxis}. It also selects the package names the
+ *   message tells the reader to trace.
+ * @see {@link DualInstantiationGuard}
+ */
+class Ledger8InstanceMismatchError extends Error {
+    axis;
+    code = PROTOCOL_ERROR_CODES.LEDGER8_INSTANCE_MISMATCH;
+    constructor(axis) {
+        const packageNames = axisPackageNames(axis).join(' and ');
+        super(`Detected two physically distinct copies of ${axis} loaded into the same process (a dual-instantiation). ` +
+            "Objects created by one copy are rejected by the other copy's classes. This usually means a duplicate " +
+            'install; the package is published under two npm scopes while the scope migration is in progress, and ' +
+            'depending on both names is itself a duplicate that no resolver can dedupe. Trace ' +
+            `${packageNames} with your package manager's \`why\` command (npm why, yarn why, pnpm why, ` +
+            'bun pm why), then align every consumer on a single package name and version.');
+        this.axis = axis;
+        this.name = 'Ledger8InstanceMismatchError';
+    }
+}
+/**
+ * Thrown by the down-convert engine (`lib/era/envelope.ts`,
+ * `lib/v8/down-convert.ts`) when it cannot turn a raw contract-state
+ * envelope, or an already-extracted `EncodedStateValue`, into an executable
+ * pre-fork state. Raised by `extractV9EncodedStateValue` (`lib/era/envelope.ts`)
+ * and `downConvertForExecution` (`lib/v8/down-convert.ts`).
+ *
+ * Renders no raw hex and no decoded state contents — only the stage name and
+ * the wrapped `cause`.
+ *
+ * @param stage Which step failed — see {@link DownConvertStage}.
+ * @param cause The runtime's own failure, preserved unchanged. It is what
+ *   distinguishes a tag mismatch from truncated, trailing, or empty input.
+ * @see {@link FailClosedDecoding}
+ */
+class DownConvertFailedError extends Error {
+    stage;
+    code = PROTOCOL_ERROR_CODES.DOWN_CONVERT_FAILED;
+    constructor(stage, cause) {
+        super(`Failed to down-convert a contract-state for execution during ${stage}. Read the wrapped cause for what ` +
+            'the runtime actually reported; it distinguishes a tag mismatch (an envelope tagged for a different ' +
+            'ledger version than the one requested) from truncated, trailing, or empty input bytes.', { cause });
+        this.stage = stage;
+        this.name = 'DownConvertFailedError';
+    }
+}
+/**
+ * Thrown by `checkRoot` (`lib/v8/down-convert.ts`) when a bounded Merkle
+ * tree's root is read before the tree has been rehashed. Reaches a caller
+ * through `assertMerkleTreesRehashed` and `downConvertForExecution`, which
+ * assert it on every tree they decode.
+ *
+ * The remediation is always the caller's: call `rehash()` on the tree before
+ * executing against it. Nothing here repairs the tree.
+ *
+ * @param cause The runtime's own failure, when reading the root threw. Absent
+ *   when `root()` returned nothing instead of throwing.
+ * @see {@link FailClosedDecoding}
+ * @see {@link RetainedEraExecution}
+ */
+class MerkleNotRehashedError extends Error {
+    code = PROTOCOL_ERROR_CODES.MERKLE_NOT_REHASHED;
+    constructor(cause) {
+        super('Attempted to read the root of a bounded Merkle tree before it was rehashed. This usually means the ' +
+            'tree was built or updated in memory and never rehashed — call rehash() on it before executing ' +
+            'against it.', { cause });
+        this.name = 'MerkleNotRehashedError';
+    }
+}
+/**
+ * What `circuitId` a {@link ComposeFailedError} names when the failure happened
+ * before any circuit was looked up — only `'call-empty'` reaches this today.
+ *
+ * Exported, and one literal rather than a per-module copy, so a consumer
+ * reading `circuitId` off a caught error can compare against it instead of
+ * matching a string this package could change, and so it can never be mistaken
+ * for a real entry point a caller might try to resolve.
+ *
+ * @see {@link ComposeRefusalOrder}
+ */
+const NO_CIRCUIT = '(none)';
+/**
+ * Thrown when a transaction cannot be composed because a circuit's operation
+ * is missing, under-registered, or names a circuit the contract does not have.
+ * `stage` (see {@link ComposeStage}) names which composition step failed and is
+ * a closed union, so a consumer can `switch` on it exhaustively; `version`
+ * names the ledger era the composition was running against.
+ *
+ * Most stages are direct assertion failures (a missing lookup, not a wrapped
+ * lower-level exception) and carry no `cause`, like
+ * {@link Ledger8InstanceMismatchError}. The exceptions are the stages where
+ * the ledger itself rejected caller-supplied bytes — enumerated under `cause`
+ * below: that failure is preserved on `cause`, the same way
+ * {@link DownConvertFailedError} preserves its runtime's own message.
+ *
+ * `circuitId` names the entry point, never its raw contents: this class
+ * renders no hex and no byte-array dump. `'call-empty'` is the one stage with
+ * no circuit to name, and its message names none.
+ *
+ * @param version The ledger era the composition was running against.
+ * @param stage Which composition step failed — see {@link ComposeStage}. A
+ *   closed union, so a consumer can `switch` on it exhaustively.
+ * @param circuitId The entry-point name, already decoded. {@link NO_CIRCUIT}
+ *   for `'call-empty'`, the one stage raised before any circuit is looked up.
+ * @param cause The runtime's own failure, present only for the stages where
+ *   the ledger itself rejected caller-supplied bytes: `'call-contract-state'`,
+ *   `'call-partition-context'`, `'call-partition'`, `'call-prototype'` and
+ *   `'deploy-verifier-key-blob'`.
+ * @see {@link ComposeRefusalOrder}
+ * @see {@link VerifierKeys}
+ */
+class ComposeFailedError extends Error {
+    version;
+    stage;
+    circuitId;
+    code = PROTOCOL_ERROR_CODES.COMPOSE_FAILED;
+    constructor(version, stage, circuitId, cause) {
+        super(ComposeFailedError.MESSAGES[stage](version, circuitId), { cause });
+        this.version = version;
+        this.stage = stage;
+        this.circuitId = circuitId;
+        this.name = 'ComposeFailedError';
+    }
+    // A total Record, and every entry takes the era rather than naming one --
+    // see SharedTableDiscipline. Keep both properties when adding a stage.
+    static MESSAGES = {
+        'wrap-call': (version, circuitId) => `Failed to compose a ${version}-native keep-state call: no registered operation found for circuit ` +
+            `'${circuitId}' on the given contract state. This usually means the contract state passed to ` +
+            'wrapKeepStateCall was not read from chain (or produced by a real deploy) — a bare/blank contract ' +
+            'state has no operations registered. Resolve the contract state that carries the deployed operation ' +
+            'for this circuit and pass that instead.',
+        'call-empty': (version) => `Refusing to compose a ${version} call transaction with no calls in it. An empty intent is accepted by ` +
+            'the ledger and serializes into a transaction that changes nothing, so the omission would only surface ' +
+            'as a call that appeared to succeed and had no effect. Pass at least one call.',
+        'call-operation': (version, circuitId) => `Failed to compose a ${version} call transaction: no registered operation found for circuit ` +
+            `'${circuitId}' on the given ${version}-native contract state. This usually means the contract state ` +
+            'passed to composeCallTx was not read from chain (or produced by a real deploy) — a bare/blank ' +
+            'contract state has no operations registered. Resolve the contract state that carries the deployed ' +
+            'operation for this circuit and pass that instead.',
+        'call-contract-state': (version, circuitId) => `Failed to compose a ${version} call transaction: the pre-call state carried by the transcript for ` +
+            `circuit '${circuitId}' could not be bridged into the ${version} ledger era. Read the wrapped cause ` +
+            'for what the decoder reported; it distinguishes a state encoded by a different runtime from ' +
+            'truncated or empty input. Pass the state the era it targets produced.',
+        'call-transcript-empty': (version, circuitId) => `Failed to compose a ${version} call: the transcript supplied for circuit '${circuitId}' carries neither ` +
+            'a guaranteed nor a fallible half, so the call would record no operations at all. A transaction built ' +
+            'from it serializes, proves and submits, and changes nothing — the same silent no-op an empty call list ' +
+            'would produce. Pass the partitioned pair the execution leg produced, at least one half of which is ' +
+            'always present for a circuit that ran.',
+        'call-dust-payout': (version, circuitId) => `Failed to compose a ${version} call: the transcript for circuit '${circuitId}' claims an unshielded ` +
+            'spend to a user address in DUST, which has no raw token type to be paid out in. The transaction ' +
+            'cannot carry that payout, and composing it anyway would tell the user they were paid while the ' +
+            'transaction paid them nothing. Settle dust through its own mechanism rather than as a claimed ' +
+            'unshielded spend.',
+        'call-unsupported-payout': (version, circuitId) => `Failed to compose a ${version} call: the transcript for circuit '${circuitId}' claims an unshielded ` +
+            'spend to a user address in a token type that cannot be paid out as an unshielded UTXO — a shielded ' +
+            'token type today. Shielded value moves through a Zswap offer, not through a claimed unshielded ' +
+            'spend, so nothing can settle this claim; composing it anyway would tell the user they were paid ' +
+            'while the transaction paid them nothing. Move the shielded value through the guaranteed or fallible ' +
+            'Zswap offer instead.',
+        'call-partition-context': (version, circuitId) => `Failed to compose a ${version} call: the ${version} era rejected the query-context state recorded ` +
+            `for circuit '${circuitId}' — its block, its starting effects, or one of the commitment indices it ` +
+            'registered for a coin received in-contract. Read the wrapped cause for the member the runtime could ' +
+            'not read. Pass the context the execution leg recorded on the transcript, unmodified.',
+        'call-partition': (version, circuitId) => `Failed to compose a ${version} call: the ${version} ledger rejected the public transcript supplied ` +
+            `for circuit '${circuitId}' while splitting it into its guaranteed and fallible halves. Read the ` +
+            'wrapped cause for what the runtime reported; it names the operation and the operand it could not ' +
+            'read. Two causes are common: a hand-built or re-encoded op sequence rather than one an execution ' +
+            'leg produced, or a call that received a coin in-contract whose recorded commitment indices never ' +
+            'reached the partitioner — a transcript that reads a received coin cannot be split without them.',
+        'call-prototype': (version, circuitId) => `Failed to compose a ${version} call: the ${version} ledger rejected the inputs supplied for circuit ` +
+            `'${circuitId}' while constructing the call prototype. Read the wrapped cause for what the runtime ` +
+            'reported; it distinguishes an out-of-range numeric field from a malformed address or aligned value. ' +
+            'Every part of a call is plain data that nothing type-checks into range, so this usually means a ' +
+            'hand-built transcript pair, private transcript output, or input/output value.',
+        'call-verifier-key': (version, circuitId) => `Failed to compose a ${version} call: the operation registered for circuit '${circuitId}' carries no ` +
+            'verifier key, so no ledger could verify a call against it. This usually means the contract state came ' +
+            'from a constructor result rather than from chain — a freshly built state declares its entry points ' +
+            'with blank keys, which only a deploy transaction fills in. Pass the contract state as read from chain ' +
+            'after a successful deploy.',
+        'deploy-verifier-key': (version, circuitId) => `Failed to compose a ${version} deploy transaction: no verifier key was supplied for circuit ` +
+            `'${circuitId}', which the contract state declares as an entry point. A deploy carrying an ` +
+            "unregistered entry point is rejected by a ledger's own well-formedness check. Resolve the compiled " +
+            "contract's verifier key for this circuit (from its keys/ artifacts) and include it in the map passed " +
+            'to composeDeployTx.',
+        'deploy-unknown-circuit': (version, circuitId) => `Failed to compose a ${version} deploy transaction: the verifier-key map names circuit '${circuitId}', ` +
+            'which the contract state does not declare as an entry point. Registering it would give the deployed ' +
+            "contract an entry point its compiled source never had, and would change the deployed contract's " +
+            'address. This usually means a stale or foreign key file was picked up (for example by globbing ' +
+            'keys/*.verifier across compiler runs) — supply keys for exactly the circuits this contract declares.',
+        'deploy-ambiguous-circuit': (version, circuitId) => `Failed to compose a ${version} deploy transaction: the contract state declares two entry points that ` +
+            `both resolve to the name '${circuitId}', so a verifier-key map keyed by name cannot tell them apart. ` +
+            'Registering under that name would key one slot and leave the other blank, deploying a contract whose ' +
+            "address does not match the caller's artifacts. This is not something a compactc-built contract " +
+            'produces — it means the contract state was assembled by hand, or by a tool that set an entry point to ' +
+            'bytes that are not valid UTF-8.',
+        'deploy-verifier-key-blob': (version, circuitId) => `Failed to compose a ${version} deploy transaction: the ledger rejected the verifier-key bytes supplied ` +
+            `for circuit '${circuitId}'. Read the wrapped cause for what the ledger reported; a verifier key must ` +
+            'be the tagged blob the compiler emits as keys/<circuit>.verifier, so this usually means a truncated ' +
+            'or empty file, or a key emitted for a different ledger era.'
+    };
+}
+/**
+ * Thrown by the composition legs when one of their options cannot be used at
+ * all, as opposed to {@link ComposeFailedError}, which reports a circuit whose
+ * operation is missing or under-registered.
+ *
+ * These are the well-formedness checks the ledger itself does not make.
+ *
+ * Like {@link DownConvertFailedError}, this class renders no input contents of
+ * its own.
+ *
+ * @param version The ledger era the option was being used against.
+ * @param option Which option was unusable — see {@link ComposeOption}. A
+ *   closed union, so a consumer can `switch` on it exhaustively.
+ * @param cause The decoder's own failure, present only for `'contractState'`
+ *   and `'zswapOffer'`, where caller-supplied bytes were rejected.
+ * @see {@link ComposeRefusalOrder}
+ * @see {@link VerifierKeys}
+ */
+class ComposeOptionError extends Error {
+    version;
+    option;
+    code = PROTOCOL_ERROR_CODES.COMPOSE_OPTION_INVALID;
+    constructor(version, option, cause) {
+        super(ComposeOptionError.MESSAGES[option](version), { cause });
+        this.version = version;
+        this.option = option;
+        this.name = 'ComposeOptionError';
+    }
+    // A total Record, for exactly the reason `ComposeFailedError.MESSAGES` above
+    // is one -- see SharedTableDiscipline. Never make this an if-chain.
+    static MESSAGES = {
+        contractState: (version) => `Failed to compose a ${version} transaction: the given contract state could not be bridged into the ` +
+            `${version} ledger era. Read the wrapped cause for what the decoder reported; it distinguishes an ` +
+            'envelope tagged for a different ledger era from truncated or empty input bytes. Pass the contract ' +
+            'state the era it targets produced, not an already down-converted or otherwise re-tagged one.',
+        ledgerParameters: (version) => `Failed to compose a ${version} transaction: the supplied ledger parameters could not be read by the ` +
+            `${version} ledger. They are era-tagged, so bytes read from a block of the other era will be refused ` +
+            'here — read the wrapped cause for the tag the decoder found. Pass the parameters the block this call ' +
+            'is built against served, which is what `RawContractState.ledgerParameters` carries.',
+        networkId: () => 'Refusing to compose a transaction against an empty network id. The ledger would accept it and bake ' +
+            'it into the transaction, which the network then rejects at submission. Resolve the network id for ' +
+            'the target environment and pass it explicitly.',
+        ttl: () => 'Refusing to compose a transaction with an invalid time-to-live. An unparseable Date is recorded by ' +
+            'the ledger as the Unix epoch, producing a transaction that has already expired. Pass a valid future ' +
+            'instant as `ttl`.',
+        calls: (version) => `Refusing to compose a ${version} call transaction from this call list: the era can compose exactly ` +
+            'one call, and composing only the first would silently drop the rest. A cross-contract call is a ' +
+            'ledger-9-only feature a pre-fork contract cannot emit, so this era has no call tree to express — ' +
+            'compose each call as its own transaction, or target the era that carries call trees.',
+        verifierKeys: (version) => `Refusing to compose a ${version} deploy transaction with no verifier-key map. This era's deploy leg ` +
+            "registers the compiled contract's keys onto the initial state itself, and a constructor-built state " +
+            'declares every entry point with a blank key — without the map the deploy would carry unregistered ' +
+            "entry points and be refused by the ledger's own well-formedness check. Supply keys for exactly the " +
+            'circuits the contract declares. An era whose deploy leg accepts the omission still refuses it for a ' +
+            'state that declares a blank-keyed entry point, for the same reason.',
+        zswapOffer: (version) => `Failed to compose a ${version} transaction: the supplied Zswap offer bytes could not be read by ` +
+            `the ${version} ledger. Read the wrapped cause for what the decoder reported. Pass the bytes that ` +
+            "era's own offer serialization produced."
+    };
+}
+/**
+ * Thrown when a raw, serialized contract-state envelope could not be read by
+ * the ledger era it was requested for. Raised by both of the facade's read
+ * paths, `extractState` and `decodeContractState`
+ * (`lib/shared/contract-state.ts`), so a caller writes one handler for both.
+ *
+ * Renders no hex and no byte dump of its own.
+ *
+ * @param version The era whose decoder rejected the envelope.
+ * @param cause The decoder's own diagnosis, preserved unchanged. It is what
+ *   distinguishes a tag mismatch from truncated, trailing or empty input.
+ * @see {@link FailClosedDecoding}
+ */
+class StateDecodeFailedError extends Error {
+    version;
+    code = PROTOCOL_ERROR_CODES.STATE_DECODE_FAILED;
+    constructor(version, cause) {
+        super(`Failed to decode a contract state for the ${version} ledger era. Read the wrapped cause for what the ` +
+            'decoder reported; it distinguishes an envelope tagged for a different ledger era from truncated, ' +
+            'trailing, or empty input bytes. Resolve the era the state was written by — protocolVersionToLedger ' +
+            'maps a raw protocolVersion integer onto it — and decode it as that era.', { cause });
+        this.version = version;
+        this.name = 'StateDecodeFailedError';
+    }
+}
+/**
+ * Thrown by `extractEncodedStateValue` (`lib/era/envelope.ts`) when the
+ * injected pre-fork runtime cannot be used — it was not passed at all, or the
+ * binding the decoder needs is absent from it. Also raised by
+ * `downConvertForExecution` (`lib/v8/down-convert.ts`) and
+ * `assertSharedLedger8Instance` (`lib/v8/instance-guard.ts`), the latter for a
+ * nullish instance probe.
+ *
+ * Nothing is wrong with the caller's input here. Distinct from
+ * {@link Ledger8RuntimeMissingError}, which reports the v8 chunk failing to
+ * load at all, and from {@link DownConvertFailedError}, which reports an
+ * envelope or state that could not be turned into an executable pre-fork
+ * state.
+ *
+ * @param missingMember Which binding was absent. One of this module's own
+ *   literals, never caller-supplied text, so it is safe to log.
+ * @see {@link FailClosedDecoding}
+ * @see {@link DualInstantiationGuard}
+ */
+class Ledger8RuntimeInvalidError extends Error {
+    missingMember;
+    code = PROTOCOL_ERROR_CODES.LEDGER8_RUNTIME_INVALID;
+    constructor(missingMember) {
+        super('The ledger-8 runtime handed to the down-convert engine cannot be used: the binding it needs is missing. ' +
+            'Pass the classes of the onchain-runtime-v3 copy your application already loaded, all of them from that ' +
+            'one copy, rather than assembling the runtime object by hand. This package exposes no accessor for it — ' +
+            'loadLedger8() resolves the v8 ledger, a different package whose own same-named classes run on a ' +
+            'separate WASM instance. Read `missingMember` on this error for the absent member.');
+        this.missingMember = missingMember;
+        this.name = 'Ledger8RuntimeInvalidError';
+    }
+}
+/**
+ * Thrown by `assertSharedLedger8Instance` (`lib/v8/instance-guard.ts`)
+ * when the `axis` it was handed is not a member of {@link Ledger8InstanceAxis}.
+ *
+ * A TypeScript caller cannot produce this — `axis` is typed as
+ * {@link Ledger8InstanceAxis}. It exists for the untyped JavaScript consumers
+ * this package also serves.
+ *
+ * @param requestedAxis The offending value that was passed. Carried for
+ *   programmatic use only; it is deliberately kept out of the message.
+ * @see {@link DualInstantiationGuard}
+ */
+class UnknownLedger8AxisError extends Error {
+    requestedAxis;
+    code = PROTOCOL_ERROR_CODES.UNKNOWN_LEDGER8_AXIS;
+    constructor(requestedAxis) {
+        super('Unknown ledger-8 instance axis requested for the shared-instance guard. The only axis this framework ' +
+            'version checks is onchain-runtime-v3; read `requestedAxis` on this error for the value that was passed.');
+        this.requestedAxis = requestedAxis;
+        this.name = 'UnknownLedger8AxisError';
+    }
+}
+/**
+ * Thrown when a ledger era was requested by a value that is not a member of
+ * `LEDGER_VERSIONS`. Raised by `loadLedgerEra` (`lib/era/load-era.ts`) and by
+ * `extractEncodedStateValue` (`lib/era/envelope.ts`).
+ *
+ * A TypeScript caller cannot produce this: `version` is typed as
+ * `LedgerVersion`. It exists for the untyped JavaScript consumers this package
+ * also serves.
+ *
+ * Carries no `version` field, unlike every other era-aware error here — there
+ * is no valid era to name.
+ *
+ * @param requestedVersion The offending value that was passed. Carried for
+ *   programmatic use only; it is deliberately kept out of the message.
+ * @see {@link SharedTableDiscipline}
+ * @see {@link FailClosedDecoding}
+ */
+class UnknownLedgerVersionError extends Error {
+    requestedVersion;
+    code = PROTOCOL_ERROR_CODES.UNKNOWN_LEDGER_VERSION;
+    constructor(requestedVersion) {
+        super('Unknown ledger version requested. Supported eras are v8 (node 1.x) and ' +
+            'v9 (node 2.x); read `requestedVersion` on this error for the value that was passed. Derive it with ' +
+            'protocolVersionToLedger rather than constructing the string by hand.');
+        this.requestedVersion = requestedVersion;
+        this.name = 'UnknownLedgerVersionError';
+    }
+}
+/**
+ * The opening of the tag every serialized ledger transaction carries, on both
+ * eras.
+ *
+ * Stops before the bracketed version deliberately: a `[vN]` is the wire-schema
+ * version of the serialized OBJECT and never a ledger era — the retained era's
+ * transactions are tagged `transaction[v9]`.
+ *
+ * @see packages/contracts/docs/verification-path.md for the same rule stated
+ *      about verifier-key tags.
+ */
+const TRANSACTION_TAG_PREFIX = 'midnight:transaction[';
+/**
+ * The bounds on a constructor name reported by {@link describeType}. It is
+ * CALLER DATA — `{ constructor: { name: ... } }` sets it to anything at all —
+ * so it is bounded in length and restricted to an identifier alphabet before
+ * it can reach an error message and from there a logger provider.
+ */
+const MAX_TYPE_NAME_LENGTH = 32;
+const TYPE_NAME_PATTERN = /^[A-Za-z0-9_$]+$/;
+/**
+ * Reads a value's constructor name, or `undefined` where it cannot be read.
+ *
+ * The read is a property access on caller data, so it can throw: an object may
+ * define `constructor` as an accessor that throws, or be an exotic object whose
+ * trap does. No operation is being attempted here — only a label chosen for a
+ * payload that has ALREADY been refused — so letting the throw propagate would
+ * replace the coded refusal with the caller's own error.
+ */
+const readConstructorName = (value) => {
+    try {
+        return value.constructor?.name;
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Names the kind of a value without reproducing any of it verbatim.
+ *
+ * Validated AFTER truncation, and that order is the point: what is checked has
+ * to be exactly what is emitted.
+ */
+const describeType = (value) => {
+    if (value === null) {
+        return 'null';
+    }
+    if (typeof value !== 'object') {
+        return typeof value;
+    }
+    const constructorName = readConstructorName(value);
+    if (typeof constructorName !== 'string') {
+        return 'object';
+    }
+    const bounded = constructorName.slice(0, MAX_TYPE_NAME_LENGTH);
+    return TYPE_NAME_PATTERN.test(bounded) ? bounded : 'object';
+};
+/**
+ * Thrown when a payload handed to a proving seam is not a serialized
+ * transaction at all.
+ *
+ * Distinct from a decode failure inside the ledger runtime: this is raised
+ * before any runtime is asked to read the bytes, so it says the caller sent the
+ * wrong KIND of payload rather than a damaged one. It covers three ways that
+ * can happen — a `txBytes` field that is not a byte string, a byte string
+ * shorter than the tag prefix, and one that does not open with the prefix.
+ *
+ * @remarks Raised by `proveV8Transaction`, so it reaches application code as a
+ * `proveTx` rejection. Match it with `hasErrorCode` against
+ * `PROTOCOL_ERROR_CODES.PAYLOAD_NOT_A_TRANSACTION` rather than constructing it.
+ */
+class PayloadNotATransactionError extends Error {
+    code = PROTOCOL_ERROR_CODES.PAYLOAD_NOT_A_TRANSACTION;
+    constructor(detail) {
+        super(`${detail} Pass the bytes produced by a sanctioned composition seam; a contract state, a ` +
+            'Zswap offer or a proof preimage is not a transaction and cannot be proved.');
+        this.name = 'PayloadNotATransactionError';
+    }
+    /**
+     * The `txBytes` field of a `v8` payload was not a `Uint8Array`. Reachable
+     * from JavaScript, from a consumer built against a pre-5.0.0
+     * `midnight-js-types`, or across an untyped boundary — so it is refused with
+     * a code rather than left to become a bare `TypeError`.
+     */
+    static notBytes(received) {
+        return new PayloadNotATransactionError(`Refusing to prove a v8 payload whose 'txBytes' is ${describeType(received)} rather than a Uint8Array.`);
+    }
+    /** The payload is a byte string, but does not open with a transaction's tag. */
+    static wrongTag(byteLength) {
+        return new PayloadNotATransactionError(`Refusing to prove a ${byteLength}-byte payload that does not begin with the ` +
+            `'${TRANSACTION_TAG_PREFIX}' tag of a serialized ledger transaction.`);
+    }
+}
+
+export { ComposeFailedError, ComposeOptionError, DownConvertFailedError, Ledger8InstanceMismatchError, Ledger8RuntimeInvalidError, Ledger8RuntimeMissingError, MerkleNotRehashedError, NO_CIRCUIT, PROTOCOL_ERROR_CODES, PayloadNotATransactionError, StateDecodeFailedError, TRANSACTION_TAG_PREFIX, UnknownLedger8AxisError, UnknownLedgerVersionError, UnknownProtocolVersionError };
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sources":["../src/errors.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;AAaG;AAIH;;;;;;AAMG;AACI,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC;AAChD,IAAA,6BAA6B,EAAE,6CAA6C;AAC5E,IAAA,kCAAkC,EAAE,kDAAkD;AACtF,IAAA,yBAAyB,EAAE,yCAAyC;AACpE,IAAA,uBAAuB,EAAE,uCAAuC;AAChE,IAAA,mBAAmB,EAAE,mCAAmC;AACxD,IAAA,mBAAmB,EAAE,mCAAmC;AACxD,IAAA,cAAc,EAAE,8BAA8B;AAC9C,IAAA,sBAAsB,EAAE,sCAAsC;AAC9D,IAAA,mBAAmB,EAAE,mCAAmC;AACxD,IAAA,sBAAsB,EAAE,sCAAsC;AAC9D,IAAA,uBAAuB,EAAE,uCAAuC;AAChE,IAAA,oBAAoB,EAAE,oCAAoC;AAC1D,IAAA,yBAAyB,EAAE;AACnB,CAAA;AAqBV;;;;;;;;;;;;;;;;;;AAkBG;AACG,MAAO,2BAA4B,SAAQ,KAAK,CAAA;AAMzC,IAAA,eAAA;AACA,IAAA,IAAA;AACA,IAAA,MAAA;AAPF,IAAA,IAAI;AAIb,IAAA,WAAA,CACW,eAAuB,EACvB,IAA2B,EAC3B,MAAoC,EAAA;QAE7C,KAAK,CACH,MAAM,KAAK;AACT,cAAE,CAAA,gEAAA,EAAmE,OAAO,eAAe,CAAA,CAAA,CAAG;AAC1F,gBAAA,CAAA,EAAG,MAAM,CAAC,eAAe,CAAC,CAAA,SAAA,EAAY,IAAI,CAAA,wDAAA,CAA0D;gBACpG,CAAA,+FAAA,CAAiG;gBACjG,CAAA,0EAAA,CAA4E;gBAC5E,CAAA,+DAAA;AACJ,cAAE,CAAA,wBAAA,EAA2B,eAAe,CAAA,QAAA,EAAW,IAAI,CAAA,OAAA,CAAS;gBAChE,CAAA,iDAAA,CAAmD;AACnD,gBAAA,CAAA,qGAAA,CAAuG,CAC9G;QAdQ,IAAA,CAAA,eAAe,GAAf,eAAe;QACf,IAAA,CAAA,IAAI,GAAJ,IAAI;QACJ,IAAA,CAAA,MAAM,GAAN,MAAM;AAaf,QAAA,IAAI,CAAC,IAAI,GAAG,6BAA6B;AACzC,QAAA,IAAI,CAAC,IAAI;AACP,YAAA,IAAI,KAAK;kBACL,oBAAoB,CAAC;AACvB,kBAAE,oBAAoB,CAAC,kCAAkC;IAC/D;AACD;AAWD;;;;;;;;;;;;;;;AAeG;AACG,MAAO,0BAA2B,SAAQ,KAAK,CAAA;AAIxC,IAAA,OAAA;AAHF,IAAA,IAAI,GAAG,oBAAoB,CAAC,uBAAuB;IAE5D,WAAA,CACW,OAA2B,EACpC,KAAc,EAAA;QAEd,KAAK,CACH,CAAA,yEAAA,EAA4E,OAAO,CAAA,iBAAA,CAAmB;YACpG,uGAAuG;AACvG,YAAA,yFAAyF,EAC3F,EAAE,KAAK,EAAE,CACV;QARQ,IAAA,CAAA,OAAO,GAAP,OAAO;AAShB,QAAA,IAAI,CAAC,IAAI,GAAG,4BAA4B;IAC1C;AACD;AAYD;;;;;;AAMG;AACH,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,iBAAiB,EAAE,gBAAgB,CAAU,CAAC;AAEtF;;;AAGG;AACH,MAAM,uBAAuB,GAAkD,MAAM,CAAC,MAAM,CAC1F,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAwC,EAAE;AACxE,IAAA,oBAAoB,EAAE;AACuB,CAAA,CAAC,CACjD;AAED,MAAM,gBAAgB,GAAG,CAAC,IAAyB,KACjD,gBAAgB,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK,CAAA,EAAG,KAAK,CAAA,CAAA,EAAI,uBAAuB,CAAC,IAAI,CAAC,CAAA,CAAE,CAAC;AAE9E;;;;;;;;;;;;AAYG;AACG,MAAO,4BAA6B,SAAQ,KAAK,CAAA;AAGhC,IAAA,IAAA;AAFZ,IAAA,IAAI,GAAG,oBAAoB,CAAC,yBAAyB;AAE9D,IAAA,WAAA,CAAqB,IAAyB,EAAA;QAC5C,MAAM,YAAY,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC;QACzD,KAAK,CACH,CAAA,2CAAA,EAA8C,IAAI,CAAA,sDAAA,CAAwD;YACxG,uGAAuG;YACvG,uGAAuG;YACvG,mFAAmF;AACnF,YAAA,CAAA,EAAG,YAAY,CAAA,2EAAA,CAA6E;AAC5F,YAAA,8EAA8E,CACjF;QATkB,IAAA,CAAA,IAAI,GAAJ,IAAI;AAUvB,QAAA,IAAI,CAAC,IAAI,GAAG,8BAA8B;IAC5C;AACD;AAWD;;;;;;;;;;;;;;AAcG;AACG,MAAO,sBAAuB,SAAQ,KAAK,CAAA;AAIpC,IAAA,KAAA;AAHF,IAAA,IAAI,GAAG,oBAAoB,CAAC,mBAAmB;IAExD,WAAA,CACW,KAAuB,EAChC,KAAc,EAAA;QAEd,KAAK,CACH,CAAA,6DAAA,EAAgE,KAAK,CAAA,kCAAA,CAAoC;YACvG,qGAAqG;AACrG,YAAA,wFAAwF,EAC1F,EAAE,KAAK,EAAE,CACV;QARQ,IAAA,CAAA,KAAK,GAAL,KAAK;AASd,QAAA,IAAI,CAAC,IAAI,GAAG,wBAAwB;IACtC;AACD;AAED;;;;;;;;;;;;;AAaG;AACG,MAAO,sBAAuB,SAAQ,KAAK,CAAA;AACtC,IAAA,IAAI,GAAG,oBAAoB,CAAC,mBAAmB;AAExD,IAAA,WAAA,CAAY,KAAe,EAAA;AACzB,QAAA,KAAK,CACH,qGAAqG;YACnG,gGAAgG;AAChG,YAAA,aAAa,EACf,EAAE,KAAK,EAAE,CACV;AACD,QAAA,IAAI,CAAC,IAAI,GAAG,wBAAwB;IACtC;AACD;AAED;;;;;;;;;;AAUG;AACI,MAAM,UAAU,GAAG;AA8E1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;AACG,MAAO,kBAAmB,SAAQ,KAAK,CAAA;AAIhC,IAAA,OAAA;AACA,IAAA,KAAA;AACA,IAAA,SAAA;AALF,IAAA,IAAI,GAAG,oBAAoB,CAAC,cAAc;AAEnD,IAAA,WAAA,CACW,OAAsB,EACtB,KAAmB,EACnB,SAAiB,EAC1B,KAAe,EAAA;AAEf,QAAA,KAAK,CAAC,kBAAkB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC;QAL/D,IAAA,CAAA,OAAO,GAAP,OAAO;QACP,IAAA,CAAA,KAAK,GAAL,KAAK;QACL,IAAA,CAAA,SAAS,GAAT,SAAS;AAIlB,QAAA,IAAI,CAAC,IAAI,GAAG,oBAAoB;IAClC;;;IAIQ,OAAgB,QAAQ,GAE5B;QACF,WAAW,EAAE,CAAC,OAAO,EAAE,SAAS,KAC9B,CAAA,oBAAA,EAAuB,OAAO,CAAA,mEAAA,CAAqE;AACnG,YAAA,CAAA,CAAA,EAAI,SAAS,CAAA,+EAAA,CAAiF;YAC9F,mGAAmG;YACnG,qGAAqG;YACrG,yCAAyC;QAC3C,YAAY,EAAE,CAAC,OAAO,KACpB,CAAA,sBAAA,EAAyB,OAAO,CAAA,sEAAA,CAAwE;YACxG,wGAAwG;YACxG,+EAA+E;QACjF,gBAAgB,EAAE,CAAC,OAAO,EAAE,SAAS,KACnC,CAAA,oBAAA,EAAuB,OAAO,CAAA,6DAAA,CAA+D;YAC7F,CAAA,CAAA,EAAI,SAAS,CAAA,eAAA,EAAkB,OAAO,CAAA,8DAAA,CAAgE;YACtG,gGAAgG;YAChG,oGAAoG;YACpG,mDAAmD;QACrD,qBAAqB,EAAE,CAAC,OAAO,EAAE,SAAS,KACxC,CAAA,oBAAA,EAAuB,OAAO,CAAA,oEAAA,CAAsE;YACpG,CAAA,SAAA,EAAY,SAAS,CAAA,gCAAA,EAAmC,OAAO,CAAA,oCAAA,CAAsC;YACrG,8FAA8F;YAC9F,uEAAuE;AACzE,QAAA,uBAAuB,EAAE,CAAC,OAAO,EAAE,SAAS,KAC1C,CAAA,oBAAA,EAAuB,OAAO,CAAA,4CAAA,EAA+C,SAAS,CAAA,kBAAA,CAAoB;YAC1G,uGAAuG;YACvG,yGAAyG;YACzG,qGAAqG;YACrG,wCAAwC;AAC1C,QAAA,kBAAkB,EAAE,CAAC,OAAO,EAAE,SAAS,KACrC,CAAA,oBAAA,EAAuB,OAAO,CAAA,mCAAA,EAAsC,SAAS,CAAA,uBAAA,CAAyB;YACtG,kGAAkG;YAClG,iGAAiG;YACjG,gGAAgG;YAChG,mBAAmB;AACrB,QAAA,yBAAyB,EAAE,CAAC,OAAO,EAAE,SAAS,KAC5C,CAAA,oBAAA,EAAuB,OAAO,CAAA,mCAAA,EAAsC,SAAS,CAAA,uBAAA,CAAyB;YACtG,qGAAqG;YACrG,iGAAiG;YACjG,kGAAkG;YAClG,sGAAsG;YACtG,sBAAsB;AACxB,QAAA,wBAAwB,EAAE,CAAC,OAAO,EAAE,SAAS,KAC3C,CAAA,oBAAA,EAAuB,OAAO,CAAA,WAAA,EAAc,OAAO,CAAA,+CAAA,CAAiD;AACpG,YAAA,CAAA,aAAA,EAAgB,SAAS,CAAA,yEAAA,CAA2E;YACpG,sGAAsG;YACtG,sFAAsF;AACxF,QAAA,gBAAgB,EAAE,CAAC,OAAO,EAAE,SAAS,KACnC,CAAA,oBAAA,EAAuB,OAAO,CAAA,WAAA,EAAc,OAAO,CAAA,gDAAA,CAAkD;AACrG,YAAA,CAAA,aAAA,EAAgB,SAAS,CAAA,uEAAA,CAAyE;YAClG,mGAAmG;YACnG,mGAAmG;YACnG,mGAAmG;YACnG,iGAAiG;AACnG,QAAA,gBAAgB,EAAE,CAAC,OAAO,EAAE,SAAS,KACnC,CAAA,oBAAA,EAAuB,OAAO,CAAA,WAAA,EAAc,OAAO,CAAA,iDAAA,CAAmD;AACtG,YAAA,CAAA,CAAA,EAAI,SAAS,CAAA,qFAAA,CAAuF;YACpG,sGAAsG;YACtG,kGAAkG;YAClG,+EAA+E;AACjF,QAAA,mBAAmB,EAAE,CAAC,OAAO,EAAE,SAAS,KACtC,CAAA,oBAAA,EAAuB,OAAO,CAAA,6CAAA,EAAgD,SAAS,CAAA,aAAA,CAAe;YACtG,wGAAwG;YACxG,qGAAqG;YACrG,wGAAwG;YACxG,4BAA4B;QAC9B,qBAAqB,EAAE,CAAC,OAAO,EAAE,SAAS,KACxC,CAAA,oBAAA,EAAuB,OAAO,CAAA,8DAAA,CAAgE;AAC9F,YAAA,CAAA,CAAA,EAAI,SAAS,CAAA,6EAAA,CAA+E;YAC5F,qGAAqG;YACrG,uGAAuG;YACvG,qBAAqB;AACvB,QAAA,wBAAwB,EAAE,CAAC,OAAO,EAAE,SAAS,KAC3C,CAAA,oBAAA,EAAuB,OAAO,CAAA,yDAAA,EAA4D,SAAS,CAAA,GAAA,CAAK;YACxG,sGAAsG;YACtG,kGAAkG;YAClG,iGAAiG;YACjG,sGAAsG;QACxG,0BAA0B,EAAE,CAAC,OAAO,EAAE,SAAS,KAC7C,CAAA,oBAAA,EAAuB,OAAO,CAAA,uEAAA,CAAyE;AACvG,YAAA,CAAA,0BAAA,EAA6B,SAAS,CAAA,+DAAA,CAAiE;YACvG,uGAAuG;YACvG,iGAAiG;YACjG,wGAAwG;YACxG,iCAAiC;QACnC,0BAA0B,EAAE,CAAC,OAAO,EAAE,SAAS,KAC7C,CAAA,oBAAA,EAAuB,OAAO,CAAA,yEAAA,CAA2E;AACzG,YAAA,CAAA,aAAA,EAAgB,SAAS,CAAA,4EAAA,CAA8E;YACvG,sGAAsG;YACtG;KACH;;AAwCH;;;;;;;;;;;;;;;;;AAiBG;AACG,MAAO,kBAAmB,SAAQ,KAAK,CAAA;AAIhC,IAAA,OAAA;AACA,IAAA,MAAA;AAJF,IAAA,IAAI,GAAG,oBAAoB,CAAC,sBAAsB;AAE3D,IAAA,WAAA,CACW,OAAsB,EACtB,MAAqB,EAC9B,KAAe,EAAA;AAEf,QAAA,KAAK,CAAC,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC;QAJrD,IAAA,CAAA,OAAO,GAAP,OAAO;QACP,IAAA,CAAA,MAAM,GAAN,MAAM;AAIf,QAAA,IAAI,CAAC,IAAI,GAAG,oBAAoB;IAClC;;;IAIQ,OAAgB,QAAQ,GAAwE;QACtG,aAAa,EAAE,CAAC,OAAO,KACrB,CAAA,oBAAA,EAAuB,OAAO,CAAA,qEAAA,CAAuE;AACrG,YAAA,CAAA,EAAG,OAAO,CAAA,uFAAA,CAAyF;YACnG,oGAAoG;YACpG,8FAA8F;QAChG,gBAAgB,EAAE,CAAC,OAAO,KACxB,CAAA,oBAAA,EAAuB,OAAO,CAAA,sEAAA,CAAwE;AACtG,YAAA,CAAA,EAAG,OAAO,CAAA,0FAAA,CAA4F;YACtG,uGAAuG;YACvG,qFAAqF;AACvF,QAAA,SAAS,EAAE,MACT,qGAAqG;YACrG,oGAAoG;YACpG,gDAAgD;AAClD,QAAA,GAAG,EAAE,MACH,qGAAqG;YACrG,sGAAsG;YACtG,mBAAmB;QACrB,KAAK,EAAE,CAAC,OAAO,KACb,CAAA,sBAAA,EAAyB,OAAO,CAAA,mEAAA,CAAqE;YACrG,kGAAkG;YAClG,mGAAmG;YACnG,sFAAsF;QACxF,YAAY,EAAE,CAAC,OAAO,KACpB,CAAA,sBAAA,EAAyB,OAAO,CAAA,oEAAA,CAAsE;YACtG,sGAAsG;YACtG,oGAAoG;YACpG,qGAAqG;YACrG,sGAAsG;YACtG,qEAAqE;QACvE,UAAU,EAAE,CAAC,OAAO,KAClB,CAAA,oBAAA,EAAuB,OAAO,CAAA,kEAAA,CAAoE;AAClG,YAAA,CAAA,IAAA,EAAO,OAAO,CAAA,mFAAA,CAAqF;YACnG;KACH;;AAGH;;;;;;;;;;;;AAYG;AACG,MAAO,sBAAuB,SAAQ,KAAK,CAAA;AAIpC,IAAA,OAAA;AAHF,IAAA,IAAI,GAAG,oBAAoB,CAAC,mBAAmB;IAExD,WAAA,CACW,OAAsB,EAC/B,KAAc,EAAA;QAEd,KAAK,CACH,CAAA,0CAAA,EAA6C,OAAO,CAAA,iDAAA,CAAmD;YACrG,mGAAmG;YACnG,qGAAqG;AACrG,YAAA,yEAAyE,EAC3E,EAAE,KAAK,EAAE,CACV;QATQ,IAAA,CAAA,OAAO,GAAP,OAAO;AAUhB,QAAA,IAAI,CAAC,IAAI,GAAG,wBAAwB;IACtC;AACD;AAED;;;;;;;;;;;;;;;;;;AAkBG;AACG,MAAO,0BAA2B,SAAQ,KAAK,CAAA;AAG9B,IAAA,aAAA;AAFZ,IAAA,IAAI,GAAG,oBAAoB,CAAC,uBAAuB;AAE5D,IAAA,WAAA,CAAqB,aAAqB,EAAA;AACxC,QAAA,KAAK,CACH,0GAA0G;YACxG,yGAAyG;YACzG,yGAAyG;YACzG,kGAAkG;AAClG,YAAA,mFAAmF,CACtF;QAPkB,IAAA,CAAA,aAAa,GAAb,aAAa;AAQhC,QAAA,IAAI,CAAC,IAAI,GAAG,4BAA4B;IAC1C;AACD;AAED;;;;;;;;;;;AAWG;AACG,MAAO,uBAAwB,SAAQ,KAAK,CAAA;AAG3B,IAAA,aAAA;AAFZ,IAAA,IAAI,GAAG,oBAAoB,CAAC,oBAAoB;AAEzD,IAAA,WAAA,CAAqB,aAAqB,EAAA;AACxC,QAAA,KAAK,CACH,uGAAuG;AACrG,YAAA,yGAAyG,CAC5G;QAJkB,IAAA,CAAA,aAAa,GAAb,aAAa;AAKhC,QAAA,IAAI,CAAC,IAAI,GAAG,yBAAyB;IACvC;AACD;AAED;;;;;;;;;;;;;;;;AAgBG;AACG,MAAO,yBAA0B,SAAQ,KAAK,CAAA;AAG7B,IAAA,gBAAA;AAFZ,IAAA,IAAI,GAAG,oBAAoB,CAAC,sBAAsB;AAE3D,IAAA,WAAA,CAAqB,gBAAwB,EAAA;AAC3C,QAAA,KAAK,CACH,yEAAyE;YACvE,qGAAqG;AACrG,YAAA,sEAAsE,CACzE;QALkB,IAAA,CAAA,gBAAgB,GAAhB,gBAAgB;AAMnC,QAAA,IAAI,CAAC,IAAI,GAAG,2BAA2B;IACzC;AACD;AAED;;;;;;;;;;AAUG;AACI,MAAM,sBAAsB,GAAG;AAEtC;;;;;AAKG;AACH,MAAM,oBAAoB,GAAG,EAAE;AAC/B,MAAM,iBAAiB,GAAG,kBAAkB;AAE5C;;;;;;;;AAQG;AACH,MAAM,mBAAmB,GAAG,CAAC,KAAa,KAAa;AACrD,IAAA,IAAI;AACF,QAAA,OAAO,KAAK,CAAC,WAAW,EAAE,IAAI;IAChC;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,SAAS;IAClB;AACF,CAAC;AAED;;;;;AAKG;AACH,MAAM,YAAY,GAAG,CAAC,KAAc,KAAY;AAC9C,IAAA,IAAI,KAAK,KAAK,IAAI,EAAE;AAClB,QAAA,OAAO,MAAM;IACf;AACA,IAAA,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;QAC7B,OAAO,OAAO,KAAK;IACrB;AACA,IAAA,MAAM,eAAe,GAAG,mBAAmB,CAAC,KAAK,CAAC;AAClD,IAAA,IAAI,OAAO,eAAe,KAAK,QAAQ,EAAE;AACvC,QAAA,OAAO,QAAQ;IACjB;IACA,MAAM,OAAO,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC,EAAE,oBAAoB,CAAC;AAC9D,IAAA,OAAO,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,OAAO,GAAG,QAAQ;AAC7D,CAAC;AAED;;;;;;;;;;;;;AAaG;AACG,MAAO,2BAA4B,SAAQ,KAAK,CAAA;AAC3C,IAAA,IAAI,GAAG,oBAAoB,CAAC,yBAAyB;AAE9D,IAAA,WAAA,CAAoB,MAAc,EAAA;QAChC,KAAK,CACH,CAAA,EAAG,MAAM,CAAA,+EAAA,CAAiF;AACxF,YAAA,4EAA4E,CAC/E;AACD,QAAA,IAAI,CAAC,IAAI,GAAG,6BAA6B;IAC3C;AAEA;;;;;AAKG;IACH,OAAO,QAAQ,CAAC,QAAiB,EAAA;QAC/B,OAAO,IAAI,2BAA2B,CACpC,CAAA,kDAAA,EAAqD,YAAY,CAAC,QAAQ,CAAC,CAAA,0BAAA,CAA4B,CACxG;IACH;;IAGA,OAAO,QAAQ,CAAC,UAAkB,EAAA;AAChC,QAAA,OAAO,IAAI,2BAA2B,CACpC,CAAA,oBAAA,EAAuB,UAAU,CAAA,2CAAA,CAA6C;YAC5E,CAAA,CAAA,EAAI,sBAAsB,CAAA,yCAAA,CAA2C,CACxE;IACH;AACD;;;;"}