@midnight-ntwrk/wallet-sdk-node-client 1.0.0-beta.10

package/dist/effect/NodeClient.d.ts

@@ -0,0 +1,21 @@
+import { Context, Effect, Stream } from 'effect';
+import * as SubmissionEvent from './SubmissionEvent.js';
+import * as NodeClientError from './NodeClientError.js';
+export type SerializedMnTransaction = Uint8Array;
+export type Genesis = {
+    readonly transactions: readonly SerializedMnTransaction[];
+};
+export interface Service {
+    sendMidnightTransaction(serializedTransaction: SerializedMnTransaction): Stream.Stream<SubmissionEvent.SubmissionEvent, NodeClientError.NodeClientError>;
+    getGenesis(): Effect.Effect<Genesis, NodeClientError.NodeClientError>;
+}
+declare const NodeClient_base: Context.TagClass<NodeClient, "@midnight-ntwrk/wallet-node-client#NodeClient", Service>;
+export declare class NodeClient extends NodeClient_base {
+}
+export declare const getGenesisTransactions: () => Effect.Effect<Genesis, NodeClientError.NodeClientError, NodeClient>;
+export declare const sendMidnightTransaction: (serializedTransaction: SerializedMnTransaction) => Stream.Stream<SubmissionEvent.SubmissionEvent, NodeClientError.NodeClientError, NodeClient>;
+export declare function sendMidnightTransactionAndWait(serializedTransaction: SerializedMnTransaction, waitFor: SubmissionEvent.Cases.Submitted['_tag']): Effect.Effect<SubmissionEvent.Cases.Submitted, NodeClientError.NodeClientError, NodeClient>;
+export declare function sendMidnightTransactionAndWait(serializedTransaction: SerializedMnTransaction, waitFor: SubmissionEvent.Cases.InBlock['_tag']): Effect.Effect<SubmissionEvent.Cases.InBlock, NodeClientError.NodeClientError, NodeClient>;
+export declare function sendMidnightTransactionAndWait(serializedTransaction: SerializedMnTransaction, waitFor: SubmissionEvent.Cases.Finalized['_tag']): Effect.Effect<SubmissionEvent.Cases.Finalized, NodeClientError.NodeClientError, NodeClient>;
+export declare function sendMidnightTransactionAndWait(serializedTransaction: SerializedMnTransaction, waitFor: SubmissionEvent.SubmissionEvent['_tag']): Effect.Effect<SubmissionEvent.SubmissionEvent, NodeClientError.NodeClientError, NodeClient>;
+export {};

package/dist/effect/NodeClient.js

@@ -0,0 +1,29 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 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.
+import { Context, Effect, Option, Stream } from 'effect';
+import * as SubmissionEvent from './SubmissionEvent.js';
+import * as NodeClientError from './NodeClientError.js';
+export class NodeClient extends Context.Tag('@midnight-ntwrk/wallet-node-client#NodeClient')() {
+}
+export const getGenesisTransactions = () => NodeClient.pipe(Effect.flatMap((client) => client.getGenesis()));
+export const sendMidnightTransaction = (serializedTransaction) => NodeClient.pipe(Stream.fromEffect, Stream.flatMap((client) => client.sendMidnightTransaction(serializedTransaction)));
+export function sendMidnightTransactionAndWait(serializedTransaction, waitFor) {
+    return sendMidnightTransaction(serializedTransaction).pipe(Stream.find(SubmissionEvent.is(waitFor)), Stream.runHead, Effect.flatMap(Option.match({
+        onNone: () => Effect.fail(new NodeClientError.TransactionProgressError({
+            message: 'Transaction did not reach desired stage and no other error was reported',
+            txData: serializedTransaction,
+            desiredStage: waitFor,
+        })),
+        onSome: (event) => Effect.succeed(event),
+    })));
+}

package/dist/effect/NodeClientError.d.ts

@@ -0,0 +1,62 @@
+import { SubmissionEvent } from './SubmissionEvent.js';
+declare const SubmissionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SubmissionError";
+} & Readonly<A>;
+export declare class SubmissionError extends SubmissionError_base<{
+    message: string;
+    txData: Uint8Array;
+    cause?: unknown;
+}> {
+}
+declare const ConnectionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ConnectionError";
+} & Readonly<A>;
+export declare class ConnectionError extends ConnectionError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+declare const TransactionProgressError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "TransactionProgressError";
+} & Readonly<A>;
+export declare class TransactionProgressError extends TransactionProgressError_base<{
+    message: string;
+    txData: Uint8Array;
+    desiredStage: SubmissionEvent['_tag'];
+}> {
+}
+declare const ParseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ParseError";
+} & Readonly<A>;
+export declare class ParseError extends ParseError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+declare const TransactionUsurpedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "TransactionUsurpedError";
+} & Readonly<A>;
+export declare class TransactionUsurpedError extends TransactionUsurpedError_base<{
+    message: string;
+    txData: Uint8Array;
+}> {
+}
+declare const TransactionDroppedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "TransactionDroppedError";
+} & Readonly<A>;
+export declare class TransactionDroppedError extends TransactionDroppedError_base<{
+    message: string;
+    txData: Uint8Array;
+}> {
+}
+declare const TransactionInvalidError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "TransactionInvalidError";
+} & Readonly<A>;
+export declare class TransactionInvalidError extends TransactionInvalidError_base<{
+    message: string;
+    txData: Uint8Array;
+    cause?: unknown;
+}> {
+}
+export type NodeClientError = SubmissionError | ConnectionError | TransactionProgressError | ParseError | TransactionUsurpedError | TransactionDroppedError | TransactionInvalidError;
+export {};

package/dist/effect/NodeClientError.js

@@ -0,0 +1,27 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 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.
+import { Data } from 'effect';
+export class SubmissionError extends Data.TaggedError('SubmissionError') {
+}
+export class ConnectionError extends Data.TaggedError('ConnectionError') {
+}
+export class TransactionProgressError extends Data.TaggedError('TransactionProgressError') {
+}
+export class ParseError extends Data.TaggedError('ParseError') {
+}
+export class TransactionUsurpedError extends Data.TaggedError('TransactionUsurpedError') {
+}
+export class TransactionDroppedError extends Data.TaggedError('TransactionDroppedError') {
+}
+export class TransactionInvalidError extends Data.TaggedError('TransactionInvalidError') {
+}

package/dist/effect/PolkadotNodeClient.d.ts

@@ -0,0 +1,29 @@
+import '../gen/augment-api.js';
+import { ApiPromise } from '@polkadot/api';
+import { Duration, Effect, Layer, Scope, Stream } from 'effect';
+import * as NodeClient from './NodeClient.js';
+import * as SubmissionEvent from './SubmissionEvent.js';
+import * as NodeClientError from './NodeClientError.js';
+export type Config = {
+    nodeURL: URL;
+    reconnectionTimeout: Duration.Duration;
+    reconnectionDelay: Duration.Duration;
+};
+export declare const DEFAULT_CONFIG: {
+    reconnectionTimeout: Duration.Duration;
+    reconnectionDelay: Duration.Duration;
+};
+export declare const makeConfig: (input: Partial<Config> & Pick<Config, "nodeURL">) => Config;
+export declare class PolkadotNodeClient implements NodeClient.Service {
+    #private;
+    static make(configInput: Partial<Config> & Pick<Config, 'nodeURL'>): Effect.Effect<PolkadotNodeClient, NodeClientError.NodeClientError, Scope.Scope>;
+    static layer(configInput: Partial<Config> & Pick<Config, 'nodeURL'>): Layer.Layer<NodeClient.NodeClient, NodeClientError.NodeClientError, Scope.Scope>;
+    readonly config: Config;
+    readonly api: ApiPromise;
+    constructor(config: Config, api: ApiPromise);
+    ensureConnection(): Effect.Effect<void, NodeClientError.NodeClientError>;
+    sendMidnightTransaction(serializedTransaction: NodeClient.SerializedMnTransaction): Stream.Stream<SubmissionEvent.SubmissionEvent, NodeClientError.NodeClientError>;
+    getGenesis(): Effect.Effect<{
+        readonly transactions: readonly NodeClient.SerializedMnTransaction[];
+    }, NodeClientError.NodeClientError>;
+}

package/dist/effect/PolkadotNodeClient.js

@@ -0,0 +1,171 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 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.
+import '../gen/augment-api.js';
+import { ApiPromise, WsProvider } from '@polkadot/api';
+import { Duration, Effect, Either, Layer, pipe, Schedule, Schema, Stream, } from 'effect';
+import * as NodeClient from './NodeClient.js';
+import * as SubmissionEvent from './SubmissionEvent.js';
+import * as NodeClientError from './NodeClientError.js';
+import BN from 'bn.js';
+import { u8aToHex } from '@polkadot/util';
+export const DEFAULT_CONFIG = {
+    reconnectionTimeout: Duration.infinity,
+    reconnectionDelay: Duration.seconds(1),
+};
+export const makeConfig = (input) => ({
+    ...DEFAULT_CONFIG,
+    ...input,
+});
+export class PolkadotNodeClient {
+    static make(configInput) {
+        const config = makeConfig(configInput);
+        return Effect.acquireRelease(Effect.promise(() => ApiPromise.create({
+            // @ts-expect-error -- exactOptionalPropertyTypes cause an incompatibility here
+            provider: new WsProvider(config.nodeURL.toString()),
+            throwOnConnect: false,
+            noInitWarn: true,
+        })), (api) => Effect.promise(() => api.disconnect())).pipe(Effect.map((api) => new PolkadotNodeClient(config, api)));
+    }
+    static layer(configInput) {
+        return Layer.effect(NodeClient.NodeClient, PolkadotNodeClient.make(configInput));
+    }
+    config;
+    api;
+    constructor(config, api) {
+        this.config = config;
+        this.api = api;
+    }
+    ensureConnection() {
+        return pipe(Effect.promise(async () => {
+            if (!this.api.isConnected) {
+                await this.api.connect();
+            }
+        }), Effect.andThen(Effect.sync(() => this.api.isConnected)), Effect.repeat({
+            until: (value) => value,
+            schedule: Schedule.spaced(this.config.reconnectionDelay),
+        }), Effect.timeout(this.config.reconnectionTimeout), Effect.asVoid, Effect.mapError((timeout) => new NodeClientError.ConnectionError({
+            message: 'Could not connect within specified time range (5s)',
+            cause: timeout,
+        })));
+    }
+    sendMidnightTransaction(serializedTransaction) {
+        const outputStream = Stream.async((emit) => {
+            const callUnsubscribe = () => unsubscribeP.then((thunk) => thunk());
+            const unsubscribeP = this.api.tx.midnight
+                .sendMnTransaction(u8aToHex(serializedTransaction))
+                .send(this.#handleSubmissionResult(serializedTransaction, emit, callUnsubscribe))
+                .catch((err) => {
+                return emit
+                    .fail(new NodeClientError.SubmissionError({
+                    message: 'Transaction submission failed',
+                    txData: serializedTransaction,
+                    cause: err,
+                }))
+                    .then(() => () => { });
+            });
+            return Effect.promise(callUnsubscribe);
+        });
+        return pipe(Stream.fromEffect(this.ensureConnection()), Stream.flatMap(() => outputStream));
+    }
+    getGenesis() {
+        return Effect.promise(() => this.api.rpc.chain.getBlock(this.api.genesisHash)).pipe(Effect.map((block) => {
+            // https://polkadot.js.org/docs/api/cookbook/blocks/#how-do-i-view-extrinsic-information
+            return {
+                transactions: block.block.extrinsics
+                    .filter((extrinsic) => extrinsic.method.section === 'midnight' && extrinsic.method.method === 'sendMnTransaction')
+                    .map((extrinsic) => extrinsic.method.args[0].toU8a()),
+            };
+        }), Effect.mapError((error) => new NodeClientError.ConnectionError({
+            message: 'Failed to retrieve genesis transactions',
+            cause: error,
+        })));
+    }
+    #handleSubmissionResult = (serializedTransaction, emit, unsubscribe) => {
+        const WithBNBlockNumber = Schema.Struct({
+            blockNumber: Schema.instanceOf(BN),
+        });
+        const emitParseError = (error) => emit.fail(new NodeClientError.ParseError({
+            message: 'Failed to parse result provided by node',
+            cause: error,
+        }));
+        const decodeBlockNumber = Schema.decodeUnknownEither(WithBNBlockNumber, {
+            errors: 'all',
+            onExcessProperty: 'ignore',
+        });
+        return async (result) => {
+            //Here's a detailed documentation about the result: https://github.com/paritytech/polkadot-sdk/blob/9b4cfe66188aa6f4408ca0463d373f0121bc1a8c/substrate/client/transaction-pool/api/src/lib.rs#L132
+            const status = result.status;
+            if (status.isReady || status.isFuture || status.isBroadcast || status.isRetracted) {
+                // The retracted status means the original block was rolled back, so transaction went back to mempool
+                await emit.single(SubmissionEvent.Submitted({ tx: serializedTransaction, txHash: result.txHash.toString() }));
+            }
+            else if (status.isInBlock) {
+                await pipe(decodeBlockNumber(result), Either.match({
+                    onLeft: emitParseError,
+                    onRight: (parsed) => {
+                        return emit.single(SubmissionEvent.InBlock({
+                            tx: serializedTransaction,
+                            blockHash: status.asInBlock.toString(),
+                            blockHeight: BigInt(parsed.blockNumber.toString(10)),
+                            txHash: result.txHash.toString(),
+                        }));
+                    },
+                }));
+            }
+            else if (status.isFinalized) {
+                await pipe(decodeBlockNumber(result), Either.match({
+                    onLeft: emitParseError,
+                    onRight: (parsed) => {
+                        return emit.single(SubmissionEvent.Finalized({
+                            tx: serializedTransaction,
+                            blockHash: status.asFinalized.toString(),
+                            blockHeight: BigInt(parsed.blockNumber.toString(10)),
+                            txHash: result.txHash.toString(),
+                        }));
+                    },
+                }));
+                await emit.end();
+                await unsubscribe();
+            }
+            else if (status.isFinalityTimeout) {
+                await emit.fail(new NodeClientError.TransactionProgressError({
+                    message: 'Transaction did not reach finality within expected time, likely consensus issues arised',
+                    desiredStage: 'Finalized',
+                    txData: serializedTransaction,
+                }));
+                await unsubscribe();
+            }
+            else if (status.isUsurped) {
+                await emit.fail(new NodeClientError.TransactionUsurpedError({
+                    message: 'Transaction got usurped (replaced by another one matching its discriminators like sender or nonce)',
+                    txData: serializedTransaction,
+                }));
+                await unsubscribe();
+            }
+            else if (status.isDropped) {
+                await emit.fail(new NodeClientError.TransactionDroppedError({
+                    message: 'Transaction got dropped, the mempool likely is full and network congested',
+                    txData: serializedTransaction,
+                }));
+                await unsubscribe();
+            }
+            else if (status.isInvalid) {
+                await emit.fail(new NodeClientError.TransactionInvalidError({
+                    message: 'Transaction got dropped, the mempool likely is full and network congested',
+                    txData: serializedTransaction,
+                }));
+                await unsubscribe();
+            }
+        };
+    };
+}

package/dist/effect/SubmissionEvent.d.ts

@@ -0,0 +1,43 @@
+import { Data } from 'effect';
+import { SerializedMnTransaction } from './NodeClient.js';
+export type HexString = string;
+export type SubmissionEvent = Cases.Submitted | Cases.InBlock | Cases.Finalized;
+export declare const Submitted: Data.Case.Constructor<Cases.Submitted, "_tag">, InBlock: Data.Case.Constructor<Cases.InBlock, "_tag">, Finalized: Data.Case.Constructor<Cases.Finalized, "_tag">, match: {
+    <const Cases extends {
+        readonly Submitted: (args: Cases.Submitted) => any;
+        readonly InBlock: (args: Cases.InBlock) => any;
+        readonly Finalized: (args: Cases.Finalized) => any;
+    }>(cases: Cases & { [K in Exclude<keyof Cases, "Submitted" | "InBlock" | "Finalized">]: never; }): (value: SubmissionEvent) => import("effect/Unify").Unify<ReturnType<Cases["Submitted" | "InBlock" | "Finalized"]>>;
+    <const Cases extends {
+        readonly Submitted: (args: Cases.Submitted) => any;
+        readonly InBlock: (args: Cases.InBlock) => any;
+        readonly Finalized: (args: Cases.Finalized) => any;
+    }>(value: SubmissionEvent, cases: Cases & { [K in Exclude<keyof Cases, "Submitted" | "InBlock" | "Finalized">]: never; }): import("effect/Unify").Unify<ReturnType<Cases["Submitted" | "InBlock" | "Finalized"]>>;
+}, is: <Tag extends "Submitted" | "InBlock" | "Finalized">(tag: Tag) => (u: unknown) => u is Extract<Cases.Submitted, {
+    readonly _tag: Tag;
+}> | Extract<Cases.InBlock, {
+    readonly _tag: Tag;
+}> | Extract<Cases.Finalized, {
+    readonly _tag: Tag;
+}>;
+export declare namespace Cases {
+    type Submitted = {
+        _tag: 'Submitted';
+        tx: SerializedMnTransaction;
+        txHash: HexString;
+    };
+    type InBlock = {
+        _tag: 'InBlock';
+        blockHash: HexString;
+        blockHeight: bigint;
+        tx: SerializedMnTransaction;
+        txHash: HexString;
+    };
+    type Finalized = {
+        _tag: 'Finalized';
+        blockHash: HexString;
+        blockHeight: bigint;
+        tx: SerializedMnTransaction;
+        txHash: HexString;
+    };
+}

package/dist/effect/SubmissionEvent.js

@@ -0,0 +1,14 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 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.
+import { Data } from 'effect';
+export const { Submitted, InBlock, Finalized, $match: match, $is: is } = Data.taggedEnum();

package/dist/effect/index.d.ts

@@ -0,0 +1,4 @@
+export * as NodeClient from './NodeClient.js';
+export * from './PolkadotNodeClient.js';
+export * as SubmissionEvent from './SubmissionEvent.js';
+export * as NodeClientError from './NodeClientError.js';

package/dist/effect/index.js

@@ -0,0 +1,16 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 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.
+export * as NodeClient from './NodeClient.js';
+export * from './PolkadotNodeClient.js';
+export * as SubmissionEvent from './SubmissionEvent.js';
+export * as NodeClientError from './NodeClientError.js';

package/dist/gen/augment-api-errors.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Auto-generated with scripts/generate-types.ts
+ * Then manually modified to only expose types and endpoints of interest
+ */
+import '@polkadot/api-base/types/errors';
+import type { ApiTypes, AugmentedError } from '@polkadot/api-base/types';
+export type __AugmentedError<ApiType extends ApiTypes> = AugmentedError<ApiType>;
+declare module '@polkadot/api-base/types/errors' {
+    interface AugmentedErrors<ApiType extends ApiTypes> {
+        midnight: {
+            ContractCallCostError: AugmentedError<ApiType>;
+            Deserialization: AugmentedError<ApiType>;
+            LedgerCacheError: AugmentedError<ApiType>;
+            LedgerStateScaleDecodingError: AugmentedError<ApiType>;
+            NewStateOutOfBounds: AugmentedError<ApiType>;
+            NoLedgerState: AugmentedError<ApiType>;
+            Serialization: AugmentedError<ApiType>;
+            Transaction: AugmentedError<ApiType>;
+        };
+    }
+}

package/dist/gen/augment-api-errors.js

@@ -0,0 +1,20 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 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.
+/* eslint-disable */
+/**
+ * Auto-generated with scripts/generate-types.ts
+ * Then manually modified to only expose types and endpoints of interest
+ */
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+import '@polkadot/api-base/types/errors';

package/dist/gen/augment-api-query.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Auto-generated with scripts/generate-types.ts
+ * Then manually modified to only expose types and endpoints of interest
+ */
+import '@polkadot/api-base/types/storage';
+import type { ApiTypes, AugmentedQuery, QueryableStorageEntry } from '@polkadot/api-base/types';
+import type { Bytes, Option } from '@polkadot/types-codec';
+import type { Observable } from '@polkadot/types/types';
+export type __AugmentedQuery<ApiType extends ApiTypes> = AugmentedQuery<ApiType, () => unknown>;
+export type __QueryableStorageEntry<ApiType extends ApiTypes> = QueryableStorageEntry<ApiType>;
+declare module '@polkadot/api-base/types/storage' {
+    interface AugmentedQueries<ApiType extends ApiTypes> {
+        midnight: {
+            networkId: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []>;
+            stateKey: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []>;
+        };
+    }
+}

package/dist/gen/augment-api-query.js

@@ -0,0 +1,20 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 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.
+/* eslint-disable */
+/**
+ * Auto-generated with scripts/generate-types.ts
+ * Then manually modified to only expose types and endpoints of interest
+ */
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+import '@polkadot/api-base/types/storage';

package/dist/gen/augment-api-tx.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Auto-generated with scripts/generate-types.ts
+ * Then manually modified to only expose types and endpoints of interest
+ */
+import '@polkadot/api-base/types/submittable';
+import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';
+import type { Bytes } from '@polkadot/types-codec';
+export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;
+export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;
+export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;
+declare module '@polkadot/api-base/types/submittable' {
+    interface AugmentedSubmittables<ApiType extends ApiTypes> {
+        midnight: {
+            sendMnTransaction: AugmentedSubmittable<(midnightTx: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [
+                Bytes
+            ]>;
+        };
+    }
+}

package/dist/gen/augment-api-tx.js

@@ -0,0 +1,20 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 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.
+/* eslint-disable */
+/**
+ * Auto-generated with scripts/generate-types.ts
+ * Then manually modified to only expose types and endpoints of interest
+ */
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+import '@polkadot/api-base/types/submittable';

package/dist/gen/augment-api.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Auto-generated with scripts/generate-types.ts
+ * Then manually modified to only expose types and endpoints of interest
+ */
+import './augment-api-errors.js';
+import './augment-api-query.js';
+import './augment-api-tx.js';

package/dist/gen/augment-api.js

@@ -0,0 +1,20 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 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.
+/* eslint-disable */
+/**
+ * Auto-generated with scripts/generate-types.ts
+ * Then manually modified to only expose types and endpoints of interest
+ */
+import './augment-api-errors.js';
+import './augment-api-query.js';
+import './augment-api-tx.js';

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { NodeClient, SubmissionEvent, Config } from './effect/index.js';
+import { Observable } from '@polkadot/types/types';
+export { Config, makeConfig, DEFAULT_CONFIG } from './effect/PolkadotNodeClient.js';
+export declare class PolkadotNodeClient {
+    #private;
+    static init(config: Config): Promise<PolkadotNodeClient>;
+    private constructor();
+    sendMidnightTransaction(serializedTransaction: NodeClient.SerializedMnTransaction): Observable<SubmissionEvent.SubmissionEvent>;
+    sendMidnightTransactionAndWait(serializedTransaction: NodeClient.SerializedMnTransaction, waitFor: SubmissionEvent.Cases.Submitted['_tag']): Promise<SubmissionEvent.Cases.Submitted>;
+    sendMidnightTransactionAndWait(serializedTransaction: NodeClient.SerializedMnTransaction, waitFor: SubmissionEvent.Cases.InBlock['_tag']): Promise<SubmissionEvent.Cases.InBlock>;
+    sendMidnightTransactionAndWait(serializedTransaction: NodeClient.SerializedMnTransaction, waitFor: SubmissionEvent.Cases.Finalized['_tag']): Promise<SubmissionEvent.Cases.Finalized>;
+    close(): Promise<void>;
+}

package/dist/index.js

@@ -0,0 +1,41 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 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.
+import { NodeClient, PolkadotNodeClient as EffectNodeClient, } from './effect/index.js';
+import { Effect, Exit, pipe, Scope } from 'effect';
+import { ObservableOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+export { makeConfig, DEFAULT_CONFIG } from './effect/PolkadotNodeClient.js';
+export class PolkadotNodeClient {
+    static init(config) {
+        return Effect.gen(function* () {
+            const scope = yield* Scope.make();
+            const client = yield* NodeClient.NodeClient.pipe(Effect.provide(EffectNodeClient.layer(config)), Effect.provideService(Scope.Scope, scope));
+            return new PolkadotNodeClient(client, scope);
+        }).pipe(Effect.runPromise);
+    }
+    #effectClient;
+    #scope;
+    constructor(effectClient, scope) {
+        this.#effectClient = effectClient;
+        this.#scope = scope;
+    }
+    sendMidnightTransaction(serializedTransaction) {
+        return ObservableOps.fromStream(this.#effectClient.sendMidnightTransaction(serializedTransaction));
+    }
+    sendMidnightTransactionAndWait(serializedTransaction, waitFor) {
+        const runRequest = (request) => pipe(request, Effect.provideService(NodeClient.NodeClient, this.#effectClient), Effect.runPromise);
+        return NodeClient.sendMidnightTransactionAndWait(serializedTransaction, waitFor).pipe(runRequest);
+    }
+    close() {
+        return Scope.close(this.#scope, Exit.void).pipe(Effect.runPromise);
+    }
+}

package/dist/testing/index.d.ts

@@ -0,0 +1 @@
+export * as TestTransactions from './test-transactions.js';

package/dist/testing/index.js

@@ -0,0 +1,13 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 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.
+export * as TestTransactions from './test-transactions.js';

package/dist/testing/normalize-txs.d.ts

@@ -0,0 +1,4 @@
+export declare function normalizeTxs(tx: string): {
+    initial_tx: string;
+    batches: string[];
+};

package/dist/testing/normalize-txs.js

@@ -0,0 +1,48 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 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.
+import { Encoding } from 'effect';
+export function normalizeTxs(tx) {
+    const normalizedTxs = {
+        initial_tx: '',
+        batches: [],
+    };
+    const data = JSON.parse(tx);
+    if (data.initial_tx) {
+        try {
+            const inner = JSON.parse(data.initial_tx);
+            if (inner.tx)
+                normalizedTxs.initial_tx = Encoding.encodeHex(inner.tx);
+        }
+        catch {
+            throw Error('Failed to parse initial_tx');
+        }
+    }
+    else {
+        throw Error('initial_tx is missing');
+    }
+    for (const batch of data.batches ?? []) {
+        for (const bufferTx of batch.txs ?? []) {
+            try {
+                const inner = JSON.parse(bufferTx);
+                if (inner.tx) {
+                    const txHex = Encoding.encodeHex(inner.tx);
+                    normalizedTxs.batches.push(txHex);
+                }
+            }
+            catch {
+                throw Error('Failed to parse batch tx');
+            }
+        }
+    }
+    return normalizedTxs;
+}

package/dist/testing/test-transactions.d.ts

@@ -0,0 +1,20 @@
+import { Error, FileSystem } from '@effect/platform';
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { SerializedTransaction } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { ProverClient } from '@midnight-ntwrk/wallet-sdk-prover-client/effect';
+import { ClientError, ServerError } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
+import { Effect, ParseResult, Schema, Stream } from 'effect';
+import { Scope } from 'effect/Scope';
+import { StartedNetwork } from 'testcontainers';
+export type FinalizedTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proof, ledger.Binding>;
+declare const TestTransactionsSchema: Schema.Struct<{
+    initial_tx: Schema.Schema<FinalizedTransaction, string, never>;
+    unbalanced_tx: Schema.Schema<FinalizedTransaction, string, never>;
+    batches: Schema.Array$<Schema.Schema<FinalizedTransaction, string, never>>;
+}>;
+export type TestTransactions = Schema.Schema.Type<typeof TestTransactionsSchema>;
+export declare const load: (file: string) => Effect.Effect<TestTransactions, ParseResult.ParseError | Error.PlatformError, FileSystem.FileSystem>;
+export declare const streamAllValid: (txs: TestTransactions) => Stream.Stream<FinalizedTransaction>;
+export declare const genUnbalancedTx: () => Effect.Effect<SerializedTransaction, ClientError | ServerError, ProverClient.ProverClient>;
+export declare const generateTestTransactions: (nodeUrl: string, proofServerUrl: string, network: StartedNetwork, outputPath: string, fileName: string) => Effect.Effect<void, Error | Error.PlatformError, FileSystem.FileSystem | Scope>;
+export {};

package/dist/testing/test-transactions.js

@@ -0,0 +1,88 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 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.
+import { FileSystem } from '@effect/platform';
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { SerializedTransaction } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { HttpProverClient, ProverClient } from '@midnight-ntwrk/wallet-sdk-prover-client/effect';
+import { TestContainers } from '@midnight-ntwrk/wallet-sdk-utilities/testing';
+import { Effect, Encoding, ParseResult, pipe, Random, Schema, Stream } from 'effect';
+import { normalizeTxs } from './normalize-txs.js';
+const TxSchema = Schema.declare((input) => input instanceof ledger.Transaction).annotations({
+    identifier: 'ledger.Transaction',
+});
+const Uint8ArraySchema = Schema.declare((input) => input instanceof Uint8Array).annotations({
+    identifier: 'Uint8Array',
+});
+const TxFromUint8Array = Schema.asSchema(Schema.transformOrFail(Uint8ArraySchema, TxSchema, {
+    encode: (tx) => Effect.sync(() => tx.serialize()),
+    decode: (bytes) => Effect.try({
+        try: () => ledger.Transaction.deserialize('signature', 'proof', 'binding', bytes),
+        catch: (err) => new ParseResult.Unexpected(err, 'Could not deserialize transaction'),
+    }),
+}));
+const HexedTx = pipe(Schema.Uint8ArrayFromHex, Schema.compose(TxFromUint8Array));
+const TestTransactionsSchema = Schema.Struct({
+    initial_tx: HexedTx,
+    unbalanced_tx: HexedTx,
+    batches: Schema.Array(HexedTx),
+});
+export const load = (file) => pipe(FileSystem.FileSystem.pipe(Effect.flatMap((fs) => fs.readFileString(file))), Effect.map((str) => JSON.parse(str)), Effect.andThen(Schema.decodeUnknown(TestTransactionsSchema, { errors: 'all' })), Effect.cached, Effect.flatten);
+export const streamAllValid = (txs) => {
+    const initial = Stream.succeed(txs.initial_tx);
+    const batches = Stream.fromIterable(txs.batches);
+    return Stream.concat(initial, batches);
+};
+export const genUnbalancedTx = () => Effect.Do.pipe(Effect.bind('value', () => Random.nextIntBetween(1, 100_000_000).pipe(Effect.map((nr) => BigInt(nr)))), Effect.bind('shieldedTokenType', () => Effect.succeed(ledger.shieldedToken())), Effect.let('unprovenTx', ({ value, shieldedTokenType }) => {
+    const recipient = ledger.ZswapSecretKeys.fromSeed(new Uint8Array(32).fill(0));
+    const coin = ledger.createShieldedCoinInfo(shieldedTokenType.raw, value);
+    const unprovenOutput = ledger.ZswapOutput.new(coin, 0, recipient.coinPublicKey, recipient.encryptionPublicKey);
+    const unprovenOffer = ledger.ZswapOffer.fromOutput(unprovenOutput, shieldedTokenType.raw, value);
+    return ledger.Transaction.fromParts('undeployed', unprovenOffer);
+}), Effect.flatMap(({ unprovenTx }) => Effect.gen(function* () {
+    const proverClient = yield* ProverClient.ProverClient;
+    const provedTx = yield* proverClient.proveTransaction(unprovenTx, ledger.CostModel.initialCostModel());
+    return SerializedTransaction(provedTx.bind().serialize());
+})));
+const normalizeAndSaveUnbalancedTx = (txsPath, tx) => {
+    /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any */
+    return Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const outputFileData = yield* fs.readFileString(txsPath, 'utf8').pipe(Effect.map((str) => normalizeTxs(str)));
+        const augmentedOutput = {
+            ...outputFileData,
+            unbalanced_tx: Encoding.encodeHex(tx),
+        };
+        yield* fs.writeFileString(txsPath, JSON.stringify(augmentedOutput));
+    });
+    /* eslint-enable */
+};
+const generateUnbalancedTransaction = (proofServerUrl) => {
+    // Originally written with `Effect.gen`, but rewritten to Do notation to debug some typing issue
+    // It seems to be a somewhat regular issue
+    return Effect.Do.pipe(Effect.bind('tx', () => genUnbalancedTx()), Effect.map(({ tx }) => tx), Effect.provide(HttpProverClient.layer({
+        url: new URL(proofServerUrl),
+    })));
+};
+export const generateTestTransactions = (nodeUrl, proofServerUrl, network, outputPath, fileName) => Effect.gen(function* () {
+    const [, unbalancedTx] = yield* Effect.all([
+        TestContainers.runTxGenerator({
+            nodeUrl: nodeUrl,
+            destPath: outputPath,
+            fileName: fileName,
+            txsPerBatch: 1,
+            batches: 1,
+        }, (c) => c.withNetwork(network)),
+        generateUnbalancedTransaction(proofServerUrl),
+    ]);
+    yield* normalizeAndSaveUnbalancedTx(`${outputPath}/${fileName}`, unbalancedTx);
+});

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@midnight-ntwrk/wallet-sdk-node-client",
+  "version": "1.0.0-beta.10",
+  "type": "module",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "Midnight Foundation",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "registry": "https://npm.pkg.github.com/"
+  },
+  "files": [
+    "dist/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/midnight-ntwrk/artifacts.git"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./effect": {
+      "types": "./dist/effect/index.d.ts",
+      "import": "./dist/effect/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.js"
+    }
+  },
+  "dependencies": {
+    "@polkadot/api": "^16.3.1",
+    "@polkadot/api-augment": "^16.3.1",
+    "@polkadot/api-base": "^16.3.1",
+    "@polkadot/rpc-augment": "^16.3.1",
+    "@polkadot/rpc-core": "^16.3.1",
+    "@polkadot/types": "^16.3.1",
+    "@polkadot/types-augment": "^16.3.1",
+    "@polkadot/types-codec": "^16.3.1",
+    "@polkadot/types-known": "^16.3.1",
+    "@polkadot/types-support": "^16.3.1",
+    "@types/bn.js": "^5.2.0",
+    "bn.js": "^5.2.2",
+    "effect": "^3.17.3",
+    "rxjs": "^7.5",
+    "testcontainers": "^11.8.1"
+  },
+  "devDependencies": {
+    "@effect/cluster": "^0.46.2",
+    "@effect/experimental": "^0.54.2",
+    "@effect/platform": "^0.90.0",
+    "@effect/platform-node": "^0.94.0",
+    "@effect/rpc": "^0.68.0",
+    "@effect/sql": "^0.44.0",
+    "@effect/workflow": "^0.8.1",
+    "@midnight-ntwrk/ledger-v6": "6.1.0-alpha.6",
+    "@midnight-ntwrk/wallet-sdk-abstractions": "1.0.0-beta.9",
+    "@midnight-ntwrk/wallet-sdk-prover-client": "1.0.0-beta.10",
+    "@midnight-ntwrk/wallet-sdk-utilities": "1.0.0-beta.7",
+    "@polkadot/typegen": "^16.3.1",
+    "@types/yargs": "^17.0.33",
+    "eslint": "^9.37.0",
+    "publint": "~0.3.14",
+    "rimraf": "^6.0.1",
+    "tsx": "^4.20.4",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4",
+    "yargs": "^18.0.0"
+  },
+  "scripts": {
+    "typecheck-script": "tsc -b ./tsconfig.script.json --noEmit",
+    "polkadot-typegen": "tsx ./scripts/generate-types.ts",
+    "typecheck": "tsc -b ./tsconfig.json --noEmit",
+    "test": "vitest run",
+    "lint": "eslint --max-warnings 0",
+    "format": "prettier --write \"**/*.{ts,js,json,yaml,yml}\"",
+    "format:check": "prettier --check \"**/*.{ts,js,json,yaml,yml}\"",
+    "dist": "tsc -b ./tsconfig.build.json",
+    "dist:publish": "tsc -b ./tsconfig.publish.json",
+    "clean": "rimraf --glob dist 'tsconfig.*.tsbuildinfo' && date +%s > .clean-timestamp",
+    "publint": "publint --strict"
+  }
+}