@midnight-ntwrk/wallet-sdk-capabilities 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/simulation/v9/SimulatorState.d.ts

@@ -0,0 +1,336 @@
+/**
+ * SimulatorState types and pure functions for state manipulation.
+ *
+ * This module contains the core data types and pure functions for working with simulator state. All functions are
+ * synchronous and side-effect free.
+ */
+import { Either, type Stream, Array as EArray } from 'effect';
+import { LedgerState, WellFormedStrictness, type TransactionResult, type ProofErasedTransaction, type SyntheticCost, type RawTokenType, type ZswapSecretKeys, type UserAddress, type SignatureVerifyingKey } from '@midnightntwrk/ledger-v9';
+import { LedgerOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+import { type NetworkId, ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { type BlockContext, type ScheduledFork, type StrictnessConfig } from '../core/index.js';
+export { blockHash, defaultStrictness, genesisStrictness, getProtocolVersion, nextBlockContextFromBlock, protocolVersionAt, scheduleFork, setProtocolVersion, type BlockContext, type ScheduledFork, type StrictnessConfig, } from '../core/index.js';
+/** A transaction included in a block with its execution result. */
+export type BlockTransaction = Readonly<{
+    /** The transaction that was executed */
+    tx: ProofErasedTransaction;
+    /** The result of executing the transaction */
+    result: TransactionResult;
+}>;
+/** A produced block containing transactions and metadata. */
+export type Block = Readonly<{
+    /** Block number (height) */
+    number: bigint;
+    /** Block hash */
+    hash: string;
+    /** Block timestamp */
+    timestamp: Date;
+    /** Transactions in this block, ordered by execution */
+    transactions: readonly BlockTransaction[];
+    /**
+     * Protocol version this block was produced under. Stamped at production time and never revised afterwards, so the
+     * chain's history records which version each block belongs to — exactly what a syncing wallet reads to decide which
+     * codec applies and when to migrate.
+     */
+    protocolVersion: ProtocolVersion.ProtocolVersion;
+}>;
+/**
+ * Pending transaction waiting for block production. Strictness is optional - if not specified, block producer assigns
+ * default when creating block.
+ */
+export type PendingTransaction = Readonly<{
+    tx: ProofErasedTransaction;
+    /** Optional per-transaction strictness. If not specified, block producer assigns default. */
+    strictness?: WellFormedStrictness;
+}>;
+/**
+ * Transaction ready for block production with strictness assigned. Block producer ensures all transactions have
+ * strictness before block creation.
+ */
+export type ReadyTransaction = Readonly<{
+    tx: ProofErasedTransaction;
+    /** Strictness for validation (assigned by block producer if not specified on pending tx). */
+    strictness: WellFormedStrictness;
+}>;
+/** Simulator state containing the ledger, block history, and pending mempool. */
+export type SimulatorState = Readonly<{
+    networkId: NetworkId.NetworkId;
+    ledger: LedgerState;
+    /** All produced blocks, ordered by block number */
+    blocks: EArray.NonEmptyArray<Block>;
+    /** Pending transactions waiting for block production */
+    mempool: readonly PendingTransaction[];
+    /** Current simulator time (independent of block numbers) */
+    currentTime: Date;
+    /** Protocol version the chain is currently on — stamped onto blocks as they are produced */
+    protocolVersion: ProtocolVersion.ProtocolVersion;
+    /** Version activations scheduled at block heights, applied when those heights are produced */
+    scheduledForks: readonly ScheduledFork[];
+}>;
+/** Result of a successful block production. */
+export type BlockInfo = Readonly<{
+    blockNumber: bigint;
+    blockHash: string;
+}>;
+/**
+ * Request to produce a block with specific transactions, fullness, and optional strictness override. This mimics how
+ * real nodes work - selecting which transactions to include and how to validate them.
+ *
+ * The block producer can optionally specify a strictness that overrides per-transaction strictness. This enables
+ * patterns like:
+ *
+ * - Enforcing balancing for all blocks after genesis
+ * - Using a decorator pattern to modify strictness behavior
+ * - Testing specific validation scenarios
+ */
+export type BlockProductionRequest = Readonly<{
+    /** Transactions to include in this block with strictness assigned */
+    transactions: readonly ReadyTransaction[];
+    /** Block fullness (0-1) for fee calculation */
+    fullness: number;
+}>;
+/**
+ * A block producer is a stream transformer that decides when blocks should be produced.
+ *
+ * It receives a stream of simulator state changes and transforms it into a stream of block production requests. Each
+ * request specifies which transactions to include and the block fullness for fee calculation.
+ *
+ * @example
+ *   ```typescript
+ *   // Custom producer: produce block when mempool has 5+ transactions
+ *   const batchedProducer: BlockProducer = (states) =>
+ *     states.pipe(
+ *       Stream.filter((s) => s.mempool.length >= 5),
+ *       Stream.map((s) => ({
+ *         transactions: [...s.mempool],
+ *         fullness: 0.5,
+ *       }))
+ *     );
+ *   ```;
+ */
+export type BlockProducer = (states: Stream.Stream<SimulatorState>) => Stream.Stream<BlockProductionRequest>;
+/** Fullness specification: static number or callback based on state. */
+export type FullnessSpec = number | ((state: SimulatorState) => number);
+/**
+ * Genesis mint specification for shielded tokens.
+ *
+ * @example
+ *   ```typescript
+ *   const mint: ShieldedGenesisMint = {
+ *     type: 'shielded',
+ *     tokenType: ledger.shieldedToken().raw,
+ *     amount: 1000n,
+ *     recipient: secretKeys,
+ *   };
+ *   ```;
+ */
+export type ShieldedGenesisMint = Readonly<{
+    type: 'shielded';
+    tokenType: RawTokenType;
+    amount: bigint;
+    recipient: ZswapSecretKeys;
+}>;
+/**
+ * Genesis mint specification for unshielded tokens.
+ *
+ * For **custom tokens**: Minted directly from nothing (enforceBalancing disabled).
+ *
+ * For **Night tokens** (native token): Requires `verifyingKey` field. Night cannot be minted from nothing due to supply
+ * invariant, so the reward/claim mechanism is used internally. Night is auto-detected by comparing `tokenType` with
+ * `ledger.nativeToken().raw`.
+ *
+ * Note: Night claims have a minimum amount requirement (~14077). Use larger amounts to ensure the claim transaction
+ * succeeds.
+ *
+ * @example
+ *   ```typescript
+ *   // Custom unshielded token
+ *   const customMint: UnshieldedGenesisMint = {
+ *     type: 'unshielded',
+ *     tokenType: customToken,
+ *     amount: 1000n,
+ *     recipient: userAddress,
+ *   };
+ *
+ *   // Night token (native token) - requires verifyingKey
+ *   const nightMint: UnshieldedGenesisMint = {
+ *     type: 'unshielded',
+ *     tokenType: ledger.nativeToken().raw,
+ *     amount: 1_000_000n, // Must exceed minimum claim amount (~14077)
+ *     recipient: userAddress,
+ *     verifyingKey: signatureVerifyingKey,
+ *   };
+ *   ```;
+ */
+export type UnshieldedGenesisMint = Readonly<{
+    type: 'unshielded';
+    tokenType: RawTokenType;
+    amount: bigint;
+    recipient: UserAddress;
+    /** Required for Night tokens (native token). Used for the claim transaction signature. */
+    verifyingKey?: SignatureVerifyingKey;
+}>;
+/**
+ * Genesis mint specification for initializing the simulator with pre-funded accounts.
+ *
+ * Uses a tagged union pattern consistent with the facade API:
+ *
+ * - **Shielded**: `{ type: 'shielded', tokenType, amount, recipient: ZswapSecretKeys }`
+ * - **Unshielded**: `{ type: 'unshielded', tokenType, amount, recipient, verifyingKey? }`
+ *
+ *   - Custom tokens: minted directly (verifyingKey not needed)
+ *   - Night tokens: auto-detected by tokenType, uses reward/claim mechanism (verifyingKey required)
+ */
+export type GenesisMint = ShieldedGenesisMint | UnshieldedGenesisMint;
+/**
+ * Assign strictness to a pending transaction, creating a ready transaction. If the pending transaction already has
+ * strictness, use it; otherwise use the provided default.
+ */
+export declare const assignStrictness: (pendingTx: PendingTransaction, defaultStrictness: WellFormedStrictness) => ReadyTransaction;
+/**
+ * Assign strictness to all pending transactions, creating ready transactions. Transactions with existing strictness
+ * keep their strictness; others get the default.
+ */
+export declare const assignStrictnessToAll: (transactions: readonly PendingTransaction[], defaultStrictness: WellFormedStrictness) => readonly ReadyTransaction[];
+/** Get the last produced block, or undefined if no blocks yet. */
+export declare const getLastBlock: (state: SimulatorState) => Block;
+/** Get the current block number (height of the last block, or 0 if no blocks). */
+export declare const getCurrentBlockNumber: (state: SimulatorState) => bigint;
+/** Get a block by its number. */
+export declare const getBlockByNumber: {
+    (number: bigint): (state: SimulatorState) => Block | undefined;
+    (state: SimulatorState, number: bigint): Block | undefined;
+};
+/** Get all transaction results from the last block. */
+export declare const getLastBlockResults: (state: SimulatorState) => readonly TransactionResult[];
+/** Get all events from the last block (flattened from all transactions). */
+export declare const getLastBlockEvents: (state: SimulatorState) => readonly TransactionResult["events"][number][];
+/**
+ * Get all events from blocks with number >= fromBlockNumber. Returns events ordered by block number, with each block's
+ * transactions flattened.
+ *
+ * Use this with the wallet's next-to-process index: `appliedIndex` after processing should be set to `lastBlockNumber +
+ * 1`, not `lastBlockNumber`.
+ */
+export declare const getBlockEventsFrom: {
+    (fromBlockNumber: bigint): (state: SimulatorState) => readonly TransactionResult['events'][number][];
+    (state: SimulatorState, fromBlockNumber: bigint): readonly TransactionResult['events'][number][];
+};
+/**
+ * @deprecated Use getBlockEventsFrom instead with proper appliedIndex semantics Get all events from blocks with number
+ *
+ * > AfterBlockNumber.
+ */
+export declare const getBlockEventsSince: {
+    (afterBlockNumber: bigint): (state: SimulatorState) => readonly TransactionResult['events'][number][];
+    (state: SimulatorState, afterBlockNumber: bigint): readonly TransactionResult['events'][number][];
+};
+/** Check if there are pending transactions in the mempool. */
+export declare const hasPendingTransactions: (state: SimulatorState) => boolean;
+/** Get the current simulator time. */
+export declare const getCurrentTime: (state: SimulatorState) => Date;
+/** Resolve fullness from spec and state. */
+export declare const resolveFullness: (spec: FullnessSpec, state: SimulatorState) => number;
+/** Create a block production request that includes all mempool transactions. */
+export declare const allMempoolTransactions: (state: SimulatorState, fullness: number, defaultStrictness: WellFormedStrictness) => BlockProductionRequest;
+/**
+ * Create a blank initial state.
+ *
+ * @param networkId - Network identifier
+ * @param options - Optional genesis parameters
+ * @param options.protocolVersion - Version the chain starts on (defaults to the minimum supported version)
+ * @param options.genesisBlockNumber - Height of the genesis block (defaults to 0; a ledger-v9 chain continues numbering
+ *   from the fork height instead)
+ * @param options.genesisTime - Timestamp of the genesis block (defaults to the epoch)
+ */
+export declare const blankState: (networkId: NetworkId.NetworkId, options?: {
+    protocolVersion?: ProtocolVersion.ProtocolVersion;
+    genesisBlockNumber?: bigint;
+    genesisTime?: Date;
+}) => Promise<SimulatorState>;
+/** Add a pending transaction to the mempool. */
+export declare const addToMempool: (state: SimulatorState, pendingTx: PendingTransaction) => SimulatorState;
+/** Remove transactions from the mempool. */
+export declare const removeFromMempool: (state: SimulatorState, transactions: readonly ReadyTransaction[]) => SimulatorState;
+/** Advance the simulator time by the given number of seconds. */
+export declare const advanceTime: (state: SimulatorState, seconds: bigint) => SimulatorState;
+/** Update the ledger state. */
+export declare const updateLedger: (state: SimulatorState, ledger: LedgerState) => SimulatorState;
+/** Append a block to the state and update time. */
+export declare const appendBlock: (state: SimulatorState, block: Block, newLedger: LedgerState) => SimulatorState;
+/**
+ * Pure state transition: apply a transaction to the simulator state. Returns Either with the new state or an error.
+ *
+ * @param state - Current simulator state
+ * @param tx - Transaction to apply
+ * @param strictness - Well-formedness strictness options
+ * @param blockContext - Block context for the transaction
+ * @param options - Optional parameters
+ * @param options.blockNumber - Override block number (defaults to last block + 1)
+ * @param options.blockFullness - Override detailed block fullness (SyntheticCost)
+ * @param options.overallBlockFullness - Override overall block fullness (0-1 value)
+ */
+export declare const applyTransaction: (state: SimulatorState, tx: ProofErasedTransaction, strictness: WellFormedStrictness, blockContext: BlockContext, options?: {
+    blockNumber?: bigint;
+    blockFullness?: SyntheticCost;
+    overallBlockFullness?: number;
+}) => Either.Either<[Block, SimulatorState], LedgerOps.LedgerError>;
+/** Result of processing a single transaction. */
+export type TransactionProcessingResult = Readonly<{
+    tx: ProofErasedTransaction;
+    result: TransactionResult;
+    newLedger: LedgerState;
+}>;
+/**
+ * Process a single pending transaction against the latest ledger state. Returns Either with the processing result or an
+ * error.
+ *
+ * @param ledger - The ledger state to process against
+ * @param readyTx - Transaction to process
+ * @param blockTime - Block timestamp
+ * @param blockContext - Block context
+ * @param minFullness - Minimum block fullness to use
+ */
+export declare const processTransaction: (ledger: LedgerState, readyTx: ReadyTransaction, blockTime: Date, blockContext: BlockContext, minFullness: number) => Either.Either<TransactionProcessingResult, LedgerOps.LedgerError>;
+/**
+ * Process multiple transactions in sequence, accumulating results. Returns Either with all results and final ledger, or
+ * first error. Each transaction uses its assigned strictness (from ReadyTransaction).
+ *
+ * @param ledger - Initial ledger state
+ * @param transactions - Transactions to process (each with assigned strictness)
+ * @param blockTime - Block timestamp
+ * @param blockContext - Block context
+ * @param fullness - Block fullness (0-1)
+ */
+export declare const processTransactions: (ledger: LedgerState, transactions: readonly ReadyTransaction[], blockTime: Date, blockContext: BlockContext, fullness: number) => Either.Either<{
+    blockTransactions: readonly BlockTransaction[];
+    finalLedger: LedgerState;
+}, LedgerOps.LedgerError>;
+/**
+ * Create a block from processed transactions and update state. Pure function that takes pre-computed block hash.
+ *
+ * @param state - Current simulator state
+ * @param blockTransactions - Processed transactions to include
+ * @param blockHash - Pre-computed block hash
+ * @param blockTime - Block timestamp
+ * @param newLedger - New ledger state after processing transactions
+ * @param processedTxs - Ready transactions to remove from mempool
+ */
+export declare const createBlock: (state: SimulatorState, blockTransactions: readonly BlockTransaction[], blockHashValue: string, blockTime: Date, newLedger: LedgerState, processedTxs: readonly ReadyTransaction[]) => [Block, SimulatorState];
+/**
+ * Create an empty block (no transactions) and update state.
+ *
+ * @param state - Current simulator state
+ * @param blockHashValue - Pre-computed block hash
+ * @param blockTime - Block timestamp
+ * @param processedTxs - Original pending transactions to remove from mempool (if any)
+ */
+export declare const createEmptyBlock: (state: SimulatorState, blockHashValue: string, blockTime: Date, processedTxs?: readonly ReadyTransaction[]) => [Block, SimulatorState];
+/**
+ * Create a WellFormedStrictness instance with configurable options. All options default to false for maximum testing
+ * flexibility.
+ *
+ * Note: WellFormedStrictness is a class from the ledger library that requires mutation to configure. This is
+ * unavoidable given the external API design.
+ */
+export declare const createStrictness: (config?: StrictnessConfig) => WellFormedStrictness;

package/dist/simulation/{SimulatorState.js → v9/SimulatorState.js}

@@ -19,33 +19,10 @@
 import { Either, Function as EFunction, Array as EArray } from 'effect';
 import { LedgerState, WellFormedStrictness, TransactionContext, } from '@midnightntwrk/ledger-v9';
 import { DateOps, LedgerOps } from '@midnight-ntwrk/wallet-sdk-utilities';
-/**
- * Default strictness for post-genesis blocks.
- *
- * In a realistic simulation:
- *
- * - Signatures should be verified (verifySignatures: true)
- * - Proofs cannot be verified because they're erased (verifyNativeProofs/verifyContractProofs: false)
- * - Limits should be enforced (enforceLimits: true)
- * - Balancing must be enforced (enforceBalancing: true) - transactions must pay fees
- *
- * Note: Genesis blocks typically disable all strictness to allow initial token distribution.
- */
-export const defaultStrictness = {
-    enforceBalancing: true,
-    verifyNativeProofs: false,
-    verifyContractProofs: false,
-    enforceLimits: true,
-    verifySignatures: true,
-};
-/** Strictness for genesis blocks - all checks disabled to allow initial token distribution. */
-export const genesisStrictness = {
-    enforceBalancing: false,
-    verifyNativeProofs: false,
-    verifyContractProofs: false,
-    enforceLimits: false,
-    verifySignatures: false,
-};
+import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { blockHash, protocolVersionAt, } from '../core/index.js';
+// Version-agnostic simulator internals, re-exported so each version's barrel presents one complete surface.
+export { blockHash, defaultStrictness, genesisStrictness, getProtocolVersion, nextBlockContextFromBlock, protocolVersionAt, scheduleFork, setProtocolVersion, } from '../core/index.js';
 /**
  * Assign strictness to a pending transaction, creating a ready transaction. If the pending transaction already has
  * strictness, use it; otherwise use the provided default.
@@ -104,20 +81,35 @@ export const allMempoolTransactions = (state, fullness, defaultStrictness) => ({
     transactions: assignStrictnessToAll(state.mempool, defaultStrictness),
     fullness,
 });
-/** Create a blank initial state. */
-export const blankState = async (networkId) => {
+/**
+ * Create a blank initial state.
+ *
+ * @param networkId - Network identifier
+ * @param options - Optional genesis parameters
+ * @param options.protocolVersion - Version the chain starts on (defaults to the minimum supported version)
+ * @param options.genesisBlockNumber - Height of the genesis block (defaults to 0; a ledger-v9 chain continues numbering
+ *   from the fork height instead)
+ * @param options.genesisTime - Timestamp of the genesis block (defaults to the epoch)
+ */
+export const blankState = async (networkId, options) => {
+    const protocolVersion = options?.protocolVersion ?? ProtocolVersion.MinSupportedVersion;
+    const genesisBlockNumber = options?.genesisBlockNumber ?? 0n;
+    const genesisTime = options?.genesisTime ?? new Date(0);
     const blankGenesis = {
-        number: 0n,
-        hash: await blockHash(0n),
-        timestamp: new Date(0),
+        number: genesisBlockNumber,
+        hash: await blockHash(genesisBlockNumber),
+        timestamp: genesisTime,
         transactions: [],
+        protocolVersion,
     };
     return {
         networkId,
         ledger: LedgerState.blank(networkId),
         blocks: [blankGenesis],
         mempool: [],
-        currentTime: new Date(0),
+        currentTime: genesisTime,
+        protocolVersion,
+        scheduledForks: [],
     };
 };
 /** Add a pending transaction to the mempool. */
@@ -172,6 +164,7 @@ export const applyTransaction = (state, tx, strictness, blockContext, options) =
         const computedBlockFullness = options?.overallBlockFullness ??
             Math.max(detailedBlockFullness.readTime, detailedBlockFullness.computeTime, detailedBlockFullness.blockUsage, detailedBlockFullness.bytesWritten, detailedBlockFullness.bytesChurned);
         const blockNumber = options?.blockNumber ?? getCurrentBlockNumber(state) + 1n;
+        const protocolVersion = protocolVersionAt(state, blockNumber);
         const blockTime = state.currentTime;
         const verifiedTransaction = tx.wellFormed(state.ledger, strictness, blockTime);
         const transactionContext = new TransactionContext(state.ledger, blockContext);
@@ -181,20 +174,22 @@ export const applyTransaction = (state, tx, strictness, blockContext, options) =
             hash: blockContext.parentBlockHash,
             timestamp: blockTime,
             transactions: [{ tx, result: txResult }],
+            protocolVersion,
         };
         const newState = {
             ...state,
             ledger: newLedgerState.postBlockUpdate(blockTime, detailedBlockFullness, computedBlockFullness),
             blocks: [...state.blocks, newBlock],
+            protocolVersion,
         };
         return [newBlock, newState];
     });
 };
 /**
- * Process a single pending transaction against the current ledger. Returns Either with the processing result or an
+ * Process a single pending transaction against the latest ledger state. Returns Either with the processing result or an
  * error.
  *
- * @param ledger - Current ledger state
+ * @param ledger - The ledger state to process against
  * @param readyTx - Transaction to process
  * @param blockTime - Block timestamp
  * @param blockContext - Block context
@@ -243,11 +238,14 @@ export const processTransactions = (ledger, transactions, blockTime, blockContex
  */
 export const createBlock = (state, blockTransactions, blockHashValue, blockTime, newLedger, processedTxs) => {
     const nextBlockNumber = getCurrentBlockNumber(state) + 1n;
+    // Resolved once, at production time: the block and the chain's current version cannot disagree.
+    const protocolVersion = protocolVersionAt(state, nextBlockNumber);
     const block = {
         number: nextBlockNumber,
         hash: blockHashValue,
         timestamp: blockTime,
         transactions: blockTransactions,
+        protocolVersion,
     };
     const txsToRemove = new Set(processedTxs.map((t) => t.tx));
     const newState = {
@@ -256,6 +254,7 @@ export const createBlock = (state, blockTransactions, blockHashValue, blockTime,
         blocks: [...state.blocks, block],
         mempool: state.mempool.filter((pending) => !txsToRemove.has(pending.tx)),
         currentTime: blockTime,
+        protocolVersion,
     };
     return [block, newState];
 };
@@ -289,35 +288,3 @@ export const createStrictness = (config = {}) => {
     strictness.verifySignatures = config.verifySignatures ?? false;
     return strictness;
 };
-/**
- * Compute block hash from block number. Uses a deterministic hash based on block number for easy recomputation.
- *
- * @param blockNumber - The block number to compute hash for
- * @returns A deterministic 64-character hex hash
- */
-export const blockHash = async (blockNumber) => {
-    const input = `block-${blockNumber.toString()}`;
-    const hashBuffer = await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(input));
-    const { Encoding } = await import('effect');
-    return Encoding.encodeHex(new Uint8Array(hashBuffer));
-};
-/**
- * Create the next block context from the previous block.
- *
- * @param previousBlock - The previous block (or undefined for genesis)
- * @param blockTime - The timestamp for the new block
- * @returns A BlockContext suitable for transaction processing
- */
-export const nextBlockContextFromBlock = async (previousBlock, blockTime) => {
-    const nextBlockNumber = previousBlock !== undefined ? previousBlock.number + 1n : 0n;
-    const hash = await blockHash(nextBlockNumber);
-    const blockSeconds = DateOps.dateToSeconds(blockTime);
-    const previousSeconds = previousBlock !== undefined ? DateOps.dateToSeconds(previousBlock.timestamp) : blockSeconds - 1n;
-    const timeSinceLastBlock = blockSeconds - previousSeconds;
-    return {
-        parentBlockHash: hash,
-        secondsSinceEpoch: blockSeconds,
-        secondsSinceEpochErr: 1, // Clock error tolerance in seconds (reasonable default for simulator)
-        lastBlockTime: timeSinceLastBlock > 0n ? timeSinceLastBlock : 1n,
-    };
-};

package/dist/simulation/v9/index.d.ts

@@ -0,0 +1,2 @@
+export { getLastBlock, getCurrentBlockNumber, getCurrentTime, getProtocolVersion, protocolVersionAt, getBlockByNumber, getLastBlockResults, getLastBlockEvents, getBlockEventsFrom, getBlockEventsSince, hasPendingTransactions, resolveFullness, allMempoolTransactions, blankState, addToMempool, removeFromMempool, advanceTime, updateLedger, appendBlock, applyTransaction, setProtocolVersion, scheduleFork, processTransaction, processTransactions, createBlock, createEmptyBlock, type TransactionProcessingResult, createStrictness, blockHash, assignStrictness, assignStrictnessToAll, defaultStrictness, genesisStrictness, type SimulatorState, type Block, type BlockTransaction, type BlockInfo, type PendingTransaction, type ReadyTransaction, type BlockProductionRequest, type BlockProducer, type FullnessSpec, type GenesisMint, type ScheduledFork, type StrictnessConfig, } from './SimulatorState.js';
+export { Simulator, immediateBlockProducer, type SimulatorConfig } from './Simulator.js';

package/dist/simulation/v9/index.js

@@ -0,0 +1,26 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// 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.
+// Re-export everything from SimulatorState
+export { 
+// State accessor functions (composable with simulator.query())
+getLastBlock, getCurrentBlockNumber, getCurrentTime, getProtocolVersion, protocolVersionAt, getBlockByNumber, getLastBlockResults, getLastBlockEvents, getBlockEventsFrom, getBlockEventsSince, hasPendingTransactions, 
+// State transformation functions
+resolveFullness, allMempoolTransactions, blankState, addToMempool, removeFromMempool, advanceTime, updateLedger, appendBlock, applyTransaction, setProtocolVersion, scheduleFork, 
+// Block production functions
+processTransaction, processTransactions, createBlock, createEmptyBlock, 
+// Helper functions
+createStrictness, blockHash, assignStrictness, assignStrictnessToAll, 
+// Strictness constants
+defaultStrictness, genesisStrictness, } from './SimulatorState.js';
+// Re-export from Simulator
+export { Simulator, immediateBlockProducer } from './Simulator.js';

package/dist/submission/submissionService.d.ts

@@ -1,7 +1,7 @@
 import { Effect } from 'effect';
 import { SubmissionEvent as SubmissionEventImported } from '@midnight-ntwrk/wallet-sdk-node-client/effect';
 import { type FinalizedTransaction } from '@midnightntwrk/ledger-v9';
-import { type SimulatorState } from '../simulation/Simulator.js';
+import { type SimulatorState } from '../simulation/v9/Simulator.js';
 export declare const SubmissionEvent: typeof SubmissionEventImported;
 export type SubmissionEvent = SubmissionEventImported.SubmissionEvent;
 export declare namespace SubmissionEventCases {
@@ -44,6 +44,7 @@ export type DefaultSubmissionConfiguration = {
 };
 export declare const makeDefaultSubmissionServiceEffect: <TTransaction extends {
     serialize: () => Uint8Array;
+    toString: () => string;
 } = FinalizedTransaction>(config: DefaultSubmissionConfiguration) => SubmissionServiceEffect<TTransaction>;
 export declare const makeDefaultSubmissionService: <TTransaction extends {
     serialize: () => Uint8Array;

package/dist/submission/submissionService.js

@@ -13,7 +13,7 @@
 import { Data, Deferred, Effect, Encoding, Exit, pipe, Scope } from 'effect';
 import { NodeClient, PolkadotNodeClient, SubmissionEvent as SubmissionEventImported, } from '@midnight-ntwrk/wallet-sdk-node-client/effect';
 import { SerializedTransaction } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { getLastBlock } from '../simulation/Simulator.js';
+import { getLastBlock } from '../simulation/v9/Simulator.js';
 export const SubmissionEvent = SubmissionEventImported;
 export class SubmissionError extends Data.TaggedError('SubmissionError') {
 }

package/dist/validation/blockData.d.ts

@@ -1,11 +1,51 @@
+import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { Either } from 'effect';
+import { LedgerParametersCodec } from '../codecs/index.js';
 import { type Simulator } from '../simulation/index.js';
-import type { BlockData } from './validationService.js';
-export type BlockDataFetcher = () => Promise<BlockData>;
+import type { AnyLedgerParameters, BlockData } from './validationService.js';
+export type BlockDataFetcher = () => Promise<BlockData<AnyLedgerParameters>>;
+/**
+ * The ledger parameters codecs validation reads blocks with, split at the version the chain forks at.
+ *
+ * @remarks
+ *   A block's parameters are bytes of whichever ledger version produced the block, and the version the indexer reports
+ *   the block under is what says which. Below the fork version they are read with ledger-v8's deserializer and from it
+ *   with the current one, so that the object handed to a validator is always one its own `LedgerState` accepts.
+ *
+ *   Nothing in the resulting type distinguishes the two: the ledger versions' `LedgerParameters` are structurally
+ *   identical, so {@link AnyLedgerParameters} is a statement of intent rather than something the compiler enforces. The
+ *   distinction is nominal at run time — the classes differ, and each ledger's WASM boundary rejects the other's —
+ *   which is why the routing has to be right rather than merely well-typed.
+ * @param forkVersion The protocol version at which the chain hands over to the ledger-v9.
+ * @returns The registry blocks are read with.
+ */
+export declare const defaultLedgerParametersCodecs: (forkVersion: ProtocolVersion.ProtocolVersion) => LedgerParametersCodec.LedgerParametersCodecs<AnyLedgerParameters>;
 export type DefaultBlockDataFetcherConfiguration = {
     indexerClientConnection: {
         indexerHttpUrl: string;
     };
+    /** Where each ledger version begins on this chain — see {@link ProtocolVersion.ForkSchedule}. */
+    forks: ProtocolVersion.ForkSchedule;
+    /** The ledger parameters codecs blocks are read with; defaults to {@link defaultLedgerParametersCodecs}. */
+    ledgerParametersCodecs?: LedgerParametersCodec.LedgerParametersCodecs<AnyLedgerParameters>;
 };
+/** The block as the indexer serves it: parameters still hex, and the version that says how to read them. */
+export type WireBlock = Readonly<{
+    hash: string;
+    height: number;
+    protocolVersion: number;
+    ledgerParameters: string;
+    timestamp: number;
+}>;
+/**
+ * Reads an indexer block into {@link BlockData}, decoding its ledger parameters with whichever registered codec claims
+ * the protocol version the block was reported under.
+ *
+ * @param codecs The ledger parameters codecs the caller is willing to read with.
+ * @param block The block as the indexer served it.
+ * @returns The block data, or the typed reason its parameters could not be read.
+ */
+export declare const blockDataFrom: (codecs: LedgerParametersCodec.LedgerParametersCodecs<AnyLedgerParameters>, block: WireBlock) => Either.Either<BlockData<AnyLedgerParameters>, LedgerParametersCodec.LedgerParametersCodecError>;
 /**
  * Builds a `BlockDataFetcher` that queries the indexer over HTTP for the latest block.
  *