@midnight-ntwrk/wallet-sdk-utilities 1.1.0 → 1.1.1

package/dist/ArrayOps.d.ts

@@ -1,4 +1,4 @@
-import { NonEmptyReadonlyArray } from 'effect/Array';
+import { type NonEmptyReadonlyArray } from 'effect/Array';
 export declare const fold: {
     <T>(folder: (acc: T, item: T) => T): (arr: NonEmptyReadonlyArray<T>) => T;
     <T>(arr: NonEmptyReadonlyArray<T>, folder: (acc: T, item: T) => T): T;

package/dist/BlobOps.d.ts

@@ -1,6 +1,6 @@
 /**
- * Browser-compatible utility for converting a Blob to Uint8Array.
- * Uses arrayBuffer() instead of bytes() for broader browser support.
+ * Browser-compatible utility for converting a Blob to Uint8Array. Uses arrayBuffer() instead of bytes() for broader
+ * browser support.
  *
  * @param blob The Blob to convert to bytes
  * @returns A Promise that resolves to a Uint8Array containing the blob's bytes

package/dist/BlobOps.js

@@ -11,8 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 /**
- * Browser-compatible utility for converting a Blob to Uint8Array.
- * Uses arrayBuffer() instead of bytes() for broader browser support.
+ * Browser-compatible utility for converting a Blob to Uint8Array. Uses arrayBuffer() instead of bytes() for broader
+ * browser support.
  *
  * @param blob The Blob to convert to bytes
  * @returns A Promise that resolves to a Uint8Array containing the blob's bytes

package/dist/EitherOps.d.ts

@@ -4,7 +4,7 @@ export declare const flatMapLeft: {
     <R, L, L2>(either: Either.Either<R, L>, cb: (l: L) => Either.Either<R, L2>): Either.Either<R, L2>;
     <R, L, L2>(cb: (l: L) => Either.Either<R, L2>): (either: Either.Either<R, L>) => Either.Either<R, L2>;
 };
-declare const LeftError_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 & {
+declare const LeftError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "LeftError";
 } & Readonly<A>;
 export declare class LeftError<L> extends LeftError_base<{

package/dist/Fluent.d.ts

@@ -1,6 +1,4 @@
 export declare namespace Fluent {
-    /**
-     * Exclude named methods from `T` so that they are no longer callable.
-     */
+    /** Exclude named methods from `T` so that they are no longer callable. */
     type ExcludeMethod<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 }

package/dist/LedgerOps.d.ts

@@ -1,5 +1,5 @@
 import { Either } from 'effect';
-declare const LedgerError_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 & {
+declare const LedgerError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "LedgerError";
 } & Readonly<A>;
 export declare class LedgerError extends LedgerError_base<{

package/dist/hlist.d.ts

@@ -1,7 +1,7 @@
-import { PolyFunction, WithTag } from './polyFunction.js';
+import { type PolyFunction, type WithTag } from './polyFunction.js';
 /**
- * Heterogeneous list - as in - list, where elements have different types
- * Here - more as an additional API over TS's tuple type
+ * Heterogeneous list - as in - list, where elements have different types Here - more as an additional API over TS's
+ * tuple type
  */
 export type Empty = [];
 export type NonEmpty<T> = T extends Array<infer E> ? [E, ...T] : never;

package/dist/networking/ClientServerErrors.d.ts

@@ -1,24 +1,22 @@
-declare const ClientError_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 & {
+declare const ClientError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "ClientError";
 } & Readonly<A>;
 /**
  * An error representing a connection or client-side error.
  *
  * @remarks
- * This error typically indicates a connection issue with a target server, or when the client has submitted some
- * data that could not be processed.
+ *   This error typically indicates a connection issue with a target server, or when the client has submitted some data
+ *   that could not be processed.
  */
 export declare class ClientError extends ClientError_base<{
     readonly message: string;
     readonly cause?: unknown;
 }> {
 }
-declare const ServerError_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 & {
+declare const ServerError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "ServerError";
 } & Readonly<A>;
-/**
- * An error representing a server-side error.
- */
+/** An error representing a server-side error. */
 export declare class ServerError extends ServerError_base<{
     readonly message: string;
 }> {

package/dist/networking/ClientServerErrors.js

@@ -15,13 +15,11 @@ import { Data } from 'effect';
  * An error representing a connection or client-side error.
  *
  * @remarks
- * This error typically indicates a connection issue with a target server, or when the client has submitted some
- * data that could not be processed.
+ *   This error typically indicates a connection issue with a target server, or when the client has submitted some data
+ *   that could not be processed.
  */
 export class ClientError extends Data.TaggedError('ClientError') {
 }
-/**
- * An error representing a server-side error.
- */
+/** An error representing a server-side error. */
 export class ServerError extends Data.TaggedError('ServerError') {
 }

package/dist/networking/HttpURL.d.ts

@@ -1,19 +1,15 @@
 import { Either } from 'effect';
 import * as Brand from 'effect/Brand';
 import { InvalidProtocolSchemeError } from './URLError.js';
-/**
- * A 'HTTP' URL.
- */
+/** A 'HTTP' URL. */
 export type HttpUrl = Brand.Branded<URL, 'HttpURL'>;
-/**
- * Constructs a 'HTTP' URL from a source URL, ensuring that the protocol is correct.
- */
+/** Constructs a 'HTTP' URL from a source URL, ensuring that the protocol is correct. */
 export declare const HttpURL: Brand.Brand.Constructor<HttpUrl>;
 /**
  * Constructs a new {@link HttpURL} from a given string.
  *
  * @param url The URL to be made into a HTTP URL.
  * @returns An `Either` that represents the valid HTTP URL constructed from `url`; or an
- * {@link InvalidProtocolSchemeError}.
+ *   {@link InvalidProtocolSchemeError}.
  */
 export declare const make: (url: URL | string) => Either.Either<HttpUrl, InvalidProtocolSchemeError>;

package/dist/networking/HttpURL.js

@@ -13,16 +13,14 @@
 import { Either } from 'effect';
 import * as Brand from 'effect/Brand';
 import { InvalidProtocolSchemeError } from './URLError.js';
-/**
- * Constructs a 'HTTP' URL from a source URL, ensuring that the protocol is correct.
- */
+/** Constructs a 'HTTP' URL from a source URL, ensuring that the protocol is correct. */
 export const HttpURL = Brand.refined((url) => url.protocol === 'http:' || url.protocol === 'https:', (url) => Brand.error(`Invalid protocol scheme '${url.protocol}'. Expected 'http:' or 'https:'`));
 /**
  * Constructs a new {@link HttpURL} from a given string.
  *
  * @param url The URL to be made into a HTTP URL.
  * @returns An `Either` that represents the valid HTTP URL constructed from `url`; or an
- * {@link InvalidProtocolSchemeError}.
+ *   {@link InvalidProtocolSchemeError}.
  */
 export const make = (url) => {
     const targetURL = new URL(url);

package/dist/networking/URLError.d.ts

@@ -1,9 +1,9 @@
-declare const InvalidProtocolSchemeError_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 & {
+declare const InvalidProtocolSchemeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "InvalidProtocolSchemeError";
 } & Readonly<A>;
 /**
- * A configuration error where the protocol scheme of a given server URL was unexpected (e.g., used
- * `'ftp:'` rather than `'http:'` for a server running over HTTP).
+ * A configuration error where the protocol scheme of a given server URL was unexpected (e.g., used `'ftp:'` rather than
+ * `'http:'` for a server running over HTTP).
  */
 export declare class InvalidProtocolSchemeError extends InvalidProtocolSchemeError_base<{
     /** A message describing the error. */
@@ -13,7 +13,7 @@ export declare class InvalidProtocolSchemeError extends InvalidProtocolSchemeErr
 }> {
     static readonly tag: "InvalidProtocolSchemeError";
 }
-declare const FailedToDeriveWebSocketUrlError_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 & {
+declare const FailedToDeriveWebSocketUrlError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "FailedToDeriveWebSocketUrlError";
 } & Readonly<A>;
 export declare class FailedToDeriveWebSocketUrlError extends FailedToDeriveWebSocketUrlError_base<{

package/dist/networking/URLError.js

@@ -12,8 +12,8 @@
 // limitations under the License.
 import { Data } from 'effect';
 /**
- * A configuration error where the protocol scheme of a given server URL was unexpected (e.g., used
- * `'ftp:'` rather than `'http:'` for a server running over HTTP).
+ * A configuration error where the protocol scheme of a given server URL was unexpected (e.g., used `'ftp:'` rather than
+ * `'http:'` for a server running over HTTP).
  */
 export class InvalidProtocolSchemeError extends Data.TaggedError('InvalidProtocolSchemeError') {
     static tag = 'InvalidProtocolSchemeError';

package/dist/networking/WsURL.d.ts

@@ -1,19 +1,15 @@
 import { Either } from 'effect';
 import * as Brand from 'effect/Brand';
 import { InvalidProtocolSchemeError } from './URLError.js';
-/**
- * A 'HTTP' URL.
- */
+/** A 'HTTP' URL. */
 export type WsURL = Brand.Branded<URL, 'WsURL'>;
-/**
- * Constructs a 'WS' URL from a source URL, ensuring that the protocol is correct.
- */
+/** Constructs a 'WS' URL from a source URL, ensuring that the protocol is correct. */
 export declare const WsURL: Brand.Brand.Constructor<WsURL>;
 /**
  * Constructs a new {@link WsURL} from a given string.
  *
  * @param url The URL to be made into a WebSocket URL.
  * @returns An `Either` that represents the valid WebSocket URL constructed from `url`; or an
- * {@link InvalidProtocolSchemeError}.
+ *   {@link InvalidProtocolSchemeError}.
  */
 export declare const make: (url: URL | string) => Either.Either<WsURL, InvalidProtocolSchemeError>;

package/dist/networking/WsURL.js

@@ -13,16 +13,14 @@
 import { Either } from 'effect';
 import * as Brand from 'effect/Brand';
 import { InvalidProtocolSchemeError } from './URLError.js';
-/**
- * Constructs a 'WS' URL from a source URL, ensuring that the protocol is correct.
- */
+/** Constructs a 'WS' URL from a source URL, ensuring that the protocol is correct. */
 export const WsURL = Brand.refined((url) => url.protocol === 'ws:' || url.protocol === 'wss:', (url) => Brand.error(`Invalid protocol scheme '${url.protocol}'. Expected 'ws:' or 'wss:'`));
 /**
  * Constructs a new {@link WsURL} from a given string.
  *
  * @param url The URL to be made into a WebSocket URL.
  * @returns An `Either` that represents the valid WebSocket URL constructed from `url`; or an
- * {@link InvalidProtocolSchemeError}.
+ *   {@link InvalidProtocolSchemeError}.
  */
 export const make = (url) => {
     const targetURL = new URL(url);

package/dist/polyFunction.d.ts

@@ -4,8 +4,8 @@ export type WithTag<T extends string | symbol> = {
 export type TagOf<T> = T extends WithTag<infer Tag> ? Tag : never;
 export type WithTagFrom<T> = WithTag<TagOf<T>>;
 /**
- * Polymorphic function - function defined for multiple types at once
- * Leveraging tagging mechanics it can predictably work at runtime and be quite intuitively defined by hand
+ * Polymorphic function - function defined for multiple types at once Leveraging tagging mechanics it can predictably
+ * work at runtime and be quite intuitively defined by hand
  */
 export type PolyFunction<Variants extends WithTag<string | symbol>, T> = {
     [V in Variants as TagOf<V>]: (variant: V) => T;

package/dist/testUtils.d.ts

@@ -1,9 +1,5 @@
-/**
- * A utility type that ensures that a given type is `true` or otherwise forces a compile time error.
- */
+/** A utility type that ensures that a given type is `true` or otherwise forces a compile time error. */
 export type Expect<T extends true> = T;
-/**
- * A utility type that exactly compares two types for equality.
- */
+/** A utility type that exactly compares two types for equality. */
 export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
 export type ItemType<T> = T extends ReadonlyArray<infer R> ? R : never;

package/dist/testing/compose.d.ts

@@ -10,19 +10,14 @@ export declare function getRepositoryRoot(): string;
  * @returns The absolute path to the compose directory
  */
 export declare function getComposeDirectory(): string;
-/**
- * Options for building test environment variables.
- */
+/** Options for building test environment variables. */
 export interface BuildTestEnvironmentVariablesOptions {
-    /**
-     * Additional environment variables to include.
-     * These will be merged with the variables collected from process.env.
-     */
+    /** Additional environment variables to include. These will be merged with the variables collected from process.env. */
     additionalVars?: Record<string, string>;
 }
 /**
- * Builds and validates environment variables for test containers.
- * Throws an error if any required environment variable from envVarsToPass is missing.
+ * Builds and validates environment variables for test containers. Throws an error if any required environment variable
+ * from envVarsToPass is missing.
  *
  * @param envVarsToPass - Array of environment variable names to collect from process.env
  * @param options - Optional configuration for building environment variables

package/dist/testing/compose.js

@@ -32,8 +32,8 @@ export function getComposeDirectory() {
     return path.join(repoRoot, 'infra', 'compose');
 }
 /**
- * Builds and validates environment variables for test containers.
- * Throws an error if any required environment variable from envVarsToPass is missing.
+ * Builds and validates environment variables for test containers. Throws an error if any required environment variable
+ * from envVarsToPass is missing.
  *
  * @param envVarsToPass - Array of environment variable names to collect from process.env
  * @param options - Optional configuration for building environment variables

package/dist/testing/test-containers.js

@@ -28,7 +28,7 @@ export const runNodeContainer = (adjustment = identity) => {
     return startContainer(adjustment(container));
 };
 export const runProofServerContainer = (adjustment = identity) => {
-    const container = new GenericContainer('ghcr.io/midnight-ntwrk/proof-server:8.0.2')
+    const container = new GenericContainer('ghcr.io/midnight-ntwrk/proof-server:8.0.3')
         .withEnvironment({
         RUST_BACKTRACE: 'full',
     })

package/dist/types.d.ts

@@ -1,15 +1,11 @@
 /**
- * A utility type that checks whether type A can be assigned to type To
- * It appears to be useful when exact inferred type are slightly too complex to express and we want the express
- * a slightly simplified type rule like Expect<CanAssign<{foo: number}, object & {foo: number}>>
+ * A utility type that checks whether type A can be assigned to type To It appears to be useful when exact inferred type
+ * are slightly too complex to express and we want the express a slightly simplified type rule like
+ * Expect<CanAssign<{foo: number}, object & {foo: number}>>
  */
 export type CanAssign<A, To> = A extends To ? true : false;
-/**
- * A utility type that ensures that a given type is `true` or otherwise forces a compile time error.
- */
+/** A utility type that ensures that a given type is `true` or otherwise forces a compile time error. */
 export type Expect<T extends true> = T;
 export type ItemType<T> = T extends ReadonlyArray<infer R> ? R : never;
-/**
- * A utility type that exactly compares two types for equality.
- */
+/** A utility type that exactly compares two types for equality. */
 export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-utilities",
   "description": "Domain-agnostic utilities for the wallet SDK - common operations and types",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",