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

package/dist/errors.d.ts

@@ -0,0 +1,467 @@
+/**
+ * The two ledger runtimes midnight-js can talk to. `v8` backs the node 1.x
+ * line; `v9` backs the 2.x line. This is a closed, exhaustive set — see
+ * `protocolVersionToLedger` (`../version.ts`) for how a raw `protocolVersion`
+ * integer maps onto it.
+ *
+ * @see {@link SharedTableDiscipline} for why the array is frozen.
+ * @see {@link ModuleGraphAndLazyLoading} for why the constant is declared in
+ * this leaf module and re-exported by `../version.ts`.
+ */
+declare const LEDGER_VERSIONS: readonly ["v8", "v9"];
+type LedgerVersion = (typeof LEDGER_VERSIONS)[number];
+
+/**
+ * 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}
+ */
+declare const PROTOCOL_ERROR_CODES: Readonly<{
+    readonly UNKNOWN_PROTOCOL_VERSION_READ: "MIDNIGHT_JS_P_UNKNOWN_PROTOCOL_VERSION_READ";
+    readonly UNKNOWN_PROTOCOL_VERSION_CONSTRUCT: "MIDNIGHT_JS_P_UNKNOWN_PROTOCOL_VERSION_CONSTRUCT";
+    readonly LEDGER8_INSTANCE_MISMATCH: "MIDNIGHT_JS_P_LEDGER8_INSTANCE_MISMATCH";
+    readonly LEDGER8_RUNTIME_MISSING: "MIDNIGHT_JS_P_LEDGER8_RUNTIME_MISSING";
+    readonly DOWN_CONVERT_FAILED: "MIDNIGHT_JS_P_DOWN_CONVERT_FAILED";
+    readonly MERKLE_NOT_REHASHED: "MIDNIGHT_JS_P_MERKLE_NOT_REHASHED";
+    readonly COMPOSE_FAILED: "MIDNIGHT_JS_P_COMPOSE_FAILED";
+    readonly COMPOSE_OPTION_INVALID: "MIDNIGHT_JS_P_COMPOSE_OPTION_INVALID";
+    readonly STATE_DECODE_FAILED: "MIDNIGHT_JS_P_STATE_DECODE_FAILED";
+    readonly UNKNOWN_LEDGER_VERSION: "MIDNIGHT_JS_P_UNKNOWN_LEDGER_VERSION";
+    readonly LEDGER8_RUNTIME_INVALID: "MIDNIGHT_JS_P_LEDGER8_RUNTIME_INVALID";
+    readonly UNKNOWN_LEDGER8_AXIS: "MIDNIGHT_JS_P_UNKNOWN_LEDGER8_AXIS";
+    readonly PAYLOAD_NOT_A_TRANSACTION: "MIDNIGHT_JS_P_PAYLOAD_NOT_A_TRANSACTION";
+}>;
+/** The union of every value in {@link PROTOCOL_ERROR_CODES}; the type of every error class's `code` field. */
+type ProtocolErrorCode = (typeof PROTOCOL_ERROR_CODES)[keyof typeof PROTOCOL_ERROR_CODES];
+/**
+ * Which call path asked for a ledger version:
+ * - `'read'` — the version was taken off an existing record.
+ * - `'construct'` — the version was chosen to build something new against the
+ *   network's current head.
+ */
+type VersionResolutionPath = 'read' | 'construct';
+/**
+ * Why `protocolVersionToLedger` could not resolve a ledger version:
+ * - `'malformed'` — the input was not even a well-formed protocolVersion
+ *   value (not a non-negative integer).
+ * - `'unknown'` — the input was a well-formed integer, but outside every
+ *   range this framework version knows how to map.
+ */
+type ProtocolVersionUnknownReason = 'unknown' | 'malformed';
+/**
+ * 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}.
+ */
+declare class UnknownProtocolVersionError extends Error {
+    readonly protocolVersion: number;
+    readonly path: VersionResolutionPath;
+    readonly reason: ProtocolVersionUnknownReason;
+    readonly code: typeof PROTOCOL_ERROR_CODES.UNKNOWN_PROTOCOL_VERSION_READ | typeof PROTOCOL_ERROR_CODES.UNKNOWN_PROTOCOL_VERSION_CONSTRUCT;
+    constructor(protocolVersion: number, path: VersionResolutionPath, reason: ProtocolVersionUnknownReason);
+}
+/**
+ * Which lazily-loaded subpath export {@link Ledger8RuntimeMissingError} failed
+ * to acquire. Each chunk pulls a different set of retained-era dependencies, so
+ * naming the wrong one sends an operator to an entry point that loaded fine.
+ *
+ * @see {@link ModuleGraphAndLazyLoading}
+ */
+type RetainedEraSubpath = '/v8' | '/engine';
+/**
+ * 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}
+ */
+declare class Ledger8RuntimeMissingError extends Error {
+    readonly subpath: RetainedEraSubpath;
+    readonly code: "MIDNIGHT_JS_P_LEDGER8_RUNTIME_MISSING";
+    constructor(subpath: RetainedEraSubpath, cause: unknown);
+}
+/**
+ * Which physical-copy axis `assertSharedLedger8Instance`
+ * (`lib/v8/instance-guard.ts`) detected two distinct instances on.
+ *
+ * `'onchain-runtime-v3'` is the only member this framework version checks.
+ *
+ * @see {@link DualInstantiationGuard}
+ */
+type Ledger8InstanceAxis = 'onchain-runtime-v3';
+/**
+ * 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}
+ */
+declare class Ledger8InstanceMismatchError extends Error {
+    readonly axis: Ledger8InstanceAxis;
+    readonly code: "MIDNIGHT_JS_P_LEDGER8_INSTANCE_MISMATCH";
+    constructor(axis: Ledger8InstanceAxis);
+}
+/**
+ * Which step of the down-convert pipeline a {@link DownConvertFailedError}
+ * came from. A closed union, so a consumer can `switch` on `stage`
+ * exhaustively.
+ *
+ * @see {@link FailClosedDecoding}
+ */
+type DownConvertStage = 'v8 envelope extraction' | 'v9 envelope extraction' | 'state down-convert';
+/**
+ * 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}
+ */
+declare class DownConvertFailedError extends Error {
+    readonly stage: DownConvertStage;
+    readonly code: "MIDNIGHT_JS_P_DOWN_CONVERT_FAILED";
+    constructor(stage: DownConvertStage, cause: unknown);
+}
+/**
+ * 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}
+ */
+declare class MerkleNotRehashedError extends Error {
+    readonly code: "MIDNIGHT_JS_P_MERKLE_NOT_REHASHED";
+    constructor(cause?: unknown);
+}
+/**
+ * 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}
+ */
+declare const NO_CIRCUIT = "(none)";
+/**
+ * Which composition step {@link ComposeFailedError} failed at.
+ *
+ * Call stages:
+ * - `'call-empty'` — a call transaction was requested with no calls in it.
+ *   The one stage that names no circuit: it is raised before any circuit is
+ *   looked up, so it names {@link NO_CIRCUIT}.
+ * - `'call-operation'` — a call leg could not resolve a registered operation
+ *   for the call's circuit on the given contract state.
+ * - `'call-verifier-key'` — a call leg resolved a registered operation for the
+ *   call's circuit, but that operation carries no verifier key, so no ledger
+ *   could verify a call against it.
+ * - `'call-contract-state'` — the call's pre-call state could not be bridged
+ *   into the target era's own state algebra. Carries the decoder's failure on
+ *   `cause`.
+ * - `'call-transcript-empty'` — a caller-supplied partitioned transcript
+ *   carried neither a guaranteed nor a fallible half, so the call would record
+ *   no operations at all.
+ * - `'call-partition-context'` — the era rejected the query-context state the
+ *   call recorded (its block, its starting effects, or one of the commitment
+ *   indices it registered for a coin received in-contract) while bridging it
+ *   onto the context the transcript is partitioned against. Carries the
+ *   runtime's own failure on `cause`.
+ * - `'call-partition'` — the ledger rejected the public transcript supplied
+ *   for a call while splitting it into its guaranteed and fallible halves.
+ *   Carries the runtime's own failure on `cause`.
+ * - `'call-prototype'` — the ledger rejected the call's own inputs while
+ *   constructing the call prototype. Carries the runtime's failure on `cause`.
+ * - `'call-dust-payout'` — a transcript claimed an unshielded spend to a user
+ *   address in DUST, which has no raw token type to be paid out in.
+ * - `'call-unsupported-payout'` — a transcript claimed an unshielded spend to
+ *   a user address in a token type that cannot be paid out as an unshielded
+ *   UTXO at all (a shielded token type today).
+ *
+ * Deploy stages:
+ * - `'deploy-verifier-key'` — a deploy leg was given no verifier key for a
+ *   circuit the contract state declares.
+ * - `'deploy-unknown-circuit'` — the verifier-key map handed to a deploy leg
+ *   names a circuit the contract state does not declare. Registering it would
+ *   add an entry point the compiled contract never had, and silently change
+ *   the deployed contract's address.
+ * - `'deploy-ambiguous-circuit'` — two entry points the contract state
+ *   declares resolve to the same name, so the verifier-key map (keyed by
+ *   name) cannot address them apart. Registering under the shared name would
+ *   key one slot and leave the other blank.
+ * - `'deploy-verifier-key-blob'` — the ledger rejected the verifier-key bytes
+ *   supplied for a circuit.
+ *
+ * Keep-state stage:
+ * - `'wrap-call'` — the keep-state leg could not resolve a registered
+ *   operation for the transcript's circuit on the given contract state.
+ *
+ * Which ledger era the failure happened on is carried separately, on the
+ * error's `version` field. Every stage but `'wrap-call'` is reachable on both
+ * eras; `'wrap-call'` is only ever raised for `'v9'`.
+ *
+ * @see {@link ComposeRefusalOrder}
+ * @see {@link VerifierKeys}
+ */
+type ComposeStage = 'wrap-call' | 'call-empty' | 'call-transcript-empty' | 'call-partition-context' | 'call-partition' | 'call-prototype' | 'call-dust-payout' | 'call-unsupported-payout' | 'call-operation' | 'call-contract-state' | 'call-verifier-key' | 'deploy-verifier-key' | 'deploy-unknown-circuit' | 'deploy-ambiguous-circuit' | 'deploy-verifier-key-blob';
+/**
+ * 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}
+ */
+declare class ComposeFailedError extends Error {
+    readonly version: LedgerVersion;
+    readonly stage: ComposeStage;
+    readonly circuitId: string;
+    readonly code: "MIDNIGHT_JS_P_COMPOSE_FAILED";
+    constructor(version: LedgerVersion, stage: ComposeStage, circuitId: string, cause?: unknown);
+    private static readonly MESSAGES;
+}
+/**
+ * Which option handed to a composition leg was unusable:
+ * - `'contractState'` — the state could not be bridged into the target
+ *   ledger era (its serialized envelope was rejected by the era's decoder).
+ * - `'networkId'` — the network id was empty. The ledger accepts an empty
+ *   string and bakes it into the transaction, so a caller that forgot to
+ *   resolve one would only find out at submission.
+ * - `'ttl'` — the time-to-live was not a valid instant. `new Date('...')` on
+ *   an unparseable value yields an Invalid Date, which the ledger silently
+ *   records as the Unix epoch: a transaction that is already expired when it
+ *   is composed.
+ * - `'calls'` — the call list is not one the target era can compose. The
+ *   retained pre-fork era composes exactly one call: a cross-contract call is a
+ *   ledger-9-only feature that a pre-fork contract cannot emit, so that era has
+ *   no call tree to express.
+ * - `'verifierKeys'` — a deploy was requested with no verifier-key map, and the
+ *   state it was given needs one. Raised on BOTH eras, for two different
+ *   reasons: the retained era's deploy leg has to register the compiled
+ *   contract's keys itself and so always needs the map, while the current era
+ *   accepts its omission for a state that already carries its keys and refuses
+ *   it only for a state still declaring a blank-keyed entry point.
+ * - `'zswapOffer'` — the supplied offer bytes were rejected by the target era's
+ *   decoder. Raised on BOTH eras, for the same reason and with the same
+ *   remediation: pass the bytes that era's own offer serialization produced.
+ *
+ * @see {@link ComposeRefusalOrder}
+ * @see {@link VerifierKeys}
+ */
+type ComposeOption = 'calls' | 'contractState' | 'ledgerParameters' | 'networkId' | 'ttl' | 'verifierKeys' | 'zswapOffer';
+/**
+ * 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}
+ */
+declare class ComposeOptionError extends Error {
+    readonly version: LedgerVersion;
+    readonly option: ComposeOption;
+    readonly code: "MIDNIGHT_JS_P_COMPOSE_OPTION_INVALID";
+    constructor(version: LedgerVersion, option: ComposeOption, cause?: unknown);
+    private static readonly MESSAGES;
+}
+/**
+ * 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}
+ */
+declare class StateDecodeFailedError extends Error {
+    readonly version: LedgerVersion;
+    readonly code: "MIDNIGHT_JS_P_STATE_DECODE_FAILED";
+    constructor(version: LedgerVersion, cause: unknown);
+}
+/**
+ * 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}
+ */
+declare class Ledger8RuntimeInvalidError extends Error {
+    readonly missingMember: string;
+    readonly code: "MIDNIGHT_JS_P_LEDGER8_RUNTIME_INVALID";
+    constructor(missingMember: string);
+}
+/**
+ * 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}
+ */
+declare class UnknownLedger8AxisError extends Error {
+    readonly requestedAxis: string;
+    readonly code: "MIDNIGHT_JS_P_UNKNOWN_LEDGER8_AXIS";
+    constructor(requestedAxis: string);
+}
+/**
+ * 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}
+ */
+declare class UnknownLedgerVersionError extends Error {
+    readonly requestedVersion: string;
+    readonly code: "MIDNIGHT_JS_P_UNKNOWN_LEDGER_VERSION";
+    constructor(requestedVersion: string);
+}
+/**
+ * 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.
+ */
+declare const TRANSACTION_TAG_PREFIX = "midnight:transaction[";
+/**
+ * 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.
+ */
+declare class PayloadNotATransactionError extends Error {
+    readonly code: "MIDNIGHT_JS_P_PAYLOAD_NOT_A_TRANSACTION";
+    private constructor();
+    /**
+     * 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: unknown): PayloadNotATransactionError;
+    /** The payload is a byte string, but does not open with a transaction's tag. */
+    static wrongTag(byteLength: number): PayloadNotATransactionError;
+}
+
+export { ComposeFailedError, ComposeOptionError, DownConvertFailedError, Ledger8InstanceMismatchError, Ledger8RuntimeInvalidError, Ledger8RuntimeMissingError, MerkleNotRehashedError, NO_CIRCUIT, PROTOCOL_ERROR_CODES, PayloadNotATransactionError, StateDecodeFailedError, TRANSACTION_TAG_PREFIX, UnknownLedger8AxisError, UnknownLedgerVersionError, UnknownProtocolVersionError };
+export type { ComposeOption, ComposeStage, DownConvertStage, Ledger8InstanceAxis, ProtocolErrorCode, ProtocolVersionUnknownReason, RetainedEraSubpath, VersionResolutionPath };