@midnight-ntwrk/wallet-sdk-indexer-client 1.0.0-beta.11

package/README.md

@@ -0,0 +1 @@
+# Wallet SDK Unshielded Token Indexer Client

package/dist/effect/ConnectionHelper.d.ts

@@ -0,0 +1,4 @@
+import * as Either from 'effect/Either';
+import { URLError } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
+export declare const deriveWebSocketUrl: (url: URL | string) => Either.Either<string, URLError>;
+export declare const createWebSocketUrl: (httpUrl: URL | string, wsUrl?: string) => Either.Either<string, URLError>;

package/dist/effect/ConnectionHelper.js

@@ -0,0 +1,29 @@
+import * as Either from 'effect/Either';
+import { FailedToDeriveWebSocketUrlError } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
+export const deriveWebSocketUrl = (url) => {
+    const httpUrl = typeof url === 'string' ? new URL(url) : url;
+    try {
+        const wsUrl = new URL(httpUrl);
+        // Convert protocol
+        wsUrl.protocol = httpUrl.protocol === 'https:' ? 'wss:' : 'ws:';
+        // Ensure pathname ends with '/ws'
+        if (!wsUrl.pathname.endsWith('/')) {
+            wsUrl.pathname += '/';
+        }
+        wsUrl.pathname += 'ws';
+        return Either.right(wsUrl.toString());
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        return Either.left(new FailedToDeriveWebSocketUrlError({
+            message: `Failed to derive WebSocket URL from ${httpUrl.toString()}`,
+            cause: error,
+        }));
+    }
+};
+export const createWebSocketUrl = (httpUrl, wsUrl) => {
+    if (wsUrl) {
+        return Either.right(wsUrl);
+    }
+    return deriveWebSocketUrl(httpUrl);
+};

package/dist/effect/HttpQueryClient.d.ts

@@ -0,0 +1,4 @@
+import { Layer, Scope } from 'effect';
+import { QueryClient } from './QueryClient.js';
+import { InvalidProtocolSchemeError } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
+export declare const layer: (config: QueryClient.ServerConfig) => Layer.Layer<QueryClient, InvalidProtocolSchemeError, Scope.Scope>;

package/dist/effect/HttpQueryClient.js

@@ -0,0 +1,38 @@
+import { Effect, Layer } from 'effect';
+import { print } from 'graphql';
+import { createClient } from 'graphql-http';
+import { QueryClient } from './QueryClient.js';
+import { ClientError, ServerError, HttpURL, } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
+export const layer = (config) => Layer.effect(QueryClient, HttpURL.make(config.url).pipe(Effect.flatMap((url) => Effect.acquireRelease(Effect.sync(() => createClient({
+    url: url.toString(),
+    shouldRetry: (error, retries) => {
+        const statusCode = error.response?.status ?? 500;
+        return Promise.resolve(retries < 3 && statusCode >= 502 && statusCode <= 504);
+    },
+})), (client) => Effect.sync(() => client.dispose()))), Effect.map((client) => new HttpQueryClientImpl(client))));
+class HttpQueryClientImpl {
+    constructor(client) {
+        this.client = client;
+    }
+    client;
+    query(document, variables) {
+        return Effect.async((resume) => {
+            let result;
+            const dispose = this.client.subscribe({ query: print(document), variables: variables }, {
+                next: (data) => (result = data),
+                error: (error) => {
+                    const statusCode = error.response?.status ?? 500;
+                    const message = error.response?.statusText ?? 'An unknown error occurred';
+                    resume(Effect.fail(statusCode >= 400 && statusCode < 500
+                        ? new ClientError({ message, cause: error })
+                        : new ServerError({ message })));
+                },
+                complete: () => resume(result.errors
+                    ? Effect.fail(new ClientError({ message: result.errors[0].message, cause: result.errors }))
+                    : Effect.succeed(result.data)),
+            });
+            // Ensure we dispose of the query if the running Fiber is terminated.
+            return Effect.sync(dispose);
+        });
+    }
+}

package/dist/effect/Query.d.ts

@@ -0,0 +1,46 @@
+import { Effect, Context } from 'effect';
+import { ClientError, ServerError } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
+import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import { QueryClient } from './QueryClient.js';
+/**
+ * Describes an invocable GraphQL query.
+ */
+export interface Query<R, V, F extends Query.QueryFn<R, V> = Query.QueryFn<R, V>> extends Effect.Effect<F> {
+    readonly tag: Context.Tag<Query<R, V>, F>;
+    readonly run: F;
+}
+export declare namespace Query {
+    /**
+     * A GraphQL query (that may be parameterized with variables), that returns a typed document.
+     *
+     * @typeParam R The type returned by the GraphQL query.
+     * @typeParam V A type that describes the variables present in the GraphQL query.
+     *
+     * @remarks
+     * `Document` is a simple type alias for `TypedDocumentNode`.
+     */
+    type Document<R, V> = TypedDocumentNode<R, V>;
+    /**
+     * The variables of a {@link Document}.
+     */
+    type Variables<T> = T extends Document<any, infer V> ? V : never;
+    /**
+     * The expected result of executing a {@link Document}.
+     */
+    type Result<T> = T extends Document<infer R, any> ? R : never;
+    /**
+     * Describes a function that executes a GraphQL query over some given variables.
+     *
+     * @param variables The variables to be used in the GraphQL query.
+     * @returns An `Effect` that will yield the result of the GraphQL query.
+     */
+    type QueryFn<R, V> = (variables: V) => Effect.Effect<R, ClientError | ServerError, QueryClient>;
+}
+/**
+ * Constructs a new invocable GraphQL query.
+ *
+ * @param name The name of the tag to be associated with this query.
+ * @param document A parsed GraphQL query document that represents the query.
+ * @returns A {@link Query}.
+ */
+export declare const make: <Name extends string, T extends Query.Document<R, V>, R = Query.Result<T>, V = Query.Variables<T>>(name: Name, document: T) => Query<R, V>;

package/dist/effect/Query.js

@@ -0,0 +1,35 @@
+import { Effect, Context, Effectable, Option, identity } from 'effect';
+import { QueryClient } from './QueryClient.js';
+/**
+ * Constructs a new invocable GraphQL query.
+ *
+ * @param name The name of the tag to be associated with this query.
+ * @param document A parsed GraphQL query document that represents the query.
+ * @returns A {@link Query}.
+ */
+export const make = (name, document) => new QueryImpl(`${name}Query`, document);
+class QueryImpl extends Effectable.Class {
+    name;
+    document;
+    constructor(name, document) {
+        super();
+        this.document = document;
+        this.name = name;
+        this.tag = Context.GenericTag(name);
+        this.run = ((variables) => Effect.flatMap(this, (f) => f(variables)));
+    }
+    tag;
+    run;
+    commit() {
+        const self = this; // eslint-disable-line @typescript-eslint/no-this-alias
+        return Effect.gen(function* () {
+            return Option.match(yield* Effect.serviceOption(self.tag), {
+                onSome: identity,
+                onNone: () => self.defaultFn.bind(self),
+            });
+        });
+    }
+    defaultFn(variables) {
+        return QueryClient.pipe(Effect.flatMap((client) => client.query(this.document, variables)));
+    }
+}

package/dist/effect/QueryClient.d.ts

@@ -0,0 +1,15 @@
+import { Effect, Context } from 'effect';
+import { ClientError, ServerError } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
+import type { Query } from './Query.js';
+declare const QueryClient_base: Context.TagClass<QueryClient, "@midnight-ntwrk/indexer-client#QueryClient", QueryClient.Service>;
+export declare class QueryClient extends QueryClient_base {
+}
+export declare namespace QueryClient {
+    interface ServerConfig {
+        readonly url: URL | string;
+    }
+    interface Service {
+        query<R, V, T extends Query.Document<R, V> = Query.Document<R, V>>(document: T, variables: V): Effect.Effect<Query.Result<T>, ClientError | ServerError>;
+    }
+}
+export {};

package/dist/effect/QueryClient.js

@@ -0,0 +1,3 @@
+import { Context } from 'effect';
+export class QueryClient extends Context.Tag('@midnight-ntwrk/indexer-client#QueryClient')() {
+}

package/dist/effect/Subscription.d.ts

@@ -0,0 +1,21 @@
+import { Effect, Stream, Context } from 'effect';
+import { ClientError, ServerError } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
+import { SubscriptionClient } from './SubscriptionClient.js';
+import type { Query } from './Query.js';
+/**
+ * Describes a subscription of elements from an invocable GraphQL query.
+ */
+export interface Subscription<R, V, F extends Subscription.SubscriptionFn<R, V> = Subscription.SubscriptionFn<R, V>> extends Effect.Effect<F> {
+    readonly tag: Context.Tag<Subscription<R, V>, F>;
+    readonly run: F;
+}
+export declare namespace Subscription {
+    /**
+     * Describes a function that streams a GraphQL subscription for some given variables.
+     *
+     * @param variables The variables to be used in the GraphQL query.
+     * @returns A `Stream` that will yield the elements of the GraphQL subscription.
+     */
+    type SubscriptionFn<R, V> = (variables: V) => Stream.Stream<R, ClientError | ServerError, SubscriptionClient>;
+}
+export declare const make: <Name extends string, T extends Query.Document<R, V>, R = Query.Result<T>, V = Query.Variables<T>>(name: Name, document: T) => Subscription<R, V>;

package/dist/effect/Subscription.js

@@ -0,0 +1,28 @@
+import { Effect, Stream, Context, Effectable, Option, identity } from 'effect';
+import { SubscriptionClient } from './SubscriptionClient.js';
+export const make = (name, document) => new SubscriptionImpl(`${name}Subscription`, document);
+class SubscriptionImpl extends Effectable.Class {
+    name;
+    document;
+    constructor(name, document) {
+        super();
+        this.document = document;
+        this.name = name;
+        this.tag = Context.GenericTag(name);
+        this.run = ((variables) => Stream.flatMap(this, (f) => f(variables)));
+    }
+    tag;
+    run;
+    commit() {
+        const self = this; // eslint-disable-line @typescript-eslint/no-this-alias
+        return Effect.gen(function* () {
+            return Option.match(yield* Effect.serviceOption(self.tag), {
+                onSome: identity,
+                onNone: () => self.defaultFn.bind(self),
+            });
+        });
+    }
+    defaultFn(variables) {
+        return SubscriptionClient.pipe(Stream.flatMap((client) => client.subscribe(this.document, variables)));
+    }
+}

package/dist/effect/SubscriptionClient.d.ts

@@ -0,0 +1,15 @@
+import { Stream, Context } from 'effect';
+import type { Query } from './Query.js';
+import { ClientError, ServerError } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
+declare const SubscriptionClient_base: Context.TagClass<SubscriptionClient, "@midnight-ntwrk/indexer-client#SubscriptionClient", SubscriptionClient.Service>;
+export declare class SubscriptionClient extends SubscriptionClient_base {
+}
+export declare namespace SubscriptionClient {
+    interface ServerConfig {
+        readonly url: URL | string;
+    }
+    interface Service {
+        subscribe<R, V, T extends Query.Document<R, V> = Query.Document<R, V>>(document: T, variables: V): Stream.Stream<Query.Result<T>, ClientError | ServerError>;
+    }
+}
+export {};

package/dist/effect/SubscriptionClient.js

@@ -0,0 +1,3 @@
+import { Context } from 'effect';
+export class SubscriptionClient extends Context.Tag('@midnight-ntwrk/indexer-client#SubscriptionClient')() {
+}

package/dist/effect/WsSubscriptionClient.d.ts

@@ -0,0 +1,4 @@
+import { Layer, Scope } from 'effect';
+import { SubscriptionClient } from './SubscriptionClient.js';
+import { InvalidProtocolSchemeError } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
+export declare const layer: (config: SubscriptionClient.ServerConfig) => Layer.Layer<SubscriptionClient, InvalidProtocolSchemeError, Scope.Scope>;

package/dist/effect/WsSubscriptionClient.js

@@ -0,0 +1,32 @@
+import { Effect, Stream, Layer } from 'effect';
+import { createClient } from 'graphql-ws';
+import { print } from 'graphql';
+import { SubscriptionClient } from './SubscriptionClient.js';
+import { WsURL, ClientError, ServerError, } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
+export const layer = (config) => Layer.effect(SubscriptionClient, WsURL.make(config.url).pipe(Effect.flatMap((url) => Effect.acquireRelease(Effect.sync(() => createClient({ url: url.toString(), shouldRetry: () => true, retryAttempts: 100 })), (client) => Effect.sync(() => client.dispose()))), Effect.map((client) => new WebSocketSubscriptionClientImpl(client))));
+class WebSocketSubscriptionClientImpl {
+    constructor(client) {
+        this.client = client;
+    }
+    client;
+    subscribe(document, variables) {
+        return Stream.async((emit) => {
+            const dispose = this.client.subscribe({ query: print(document), variables: variables }, {
+                next: (data) => {
+                    if (data.errors) {
+                        return void emit.fail(new ClientError({ message: data.errors[0].message, cause: data.errors }));
+                    }
+                    void emit.single(data.data);
+                },
+                error: (err) => {
+                    void emit.fail(Array.isArray(err)
+                        ? new ClientError({ message: err[0].message })
+                        : new ServerError({ message: String(err) }));
+                },
+                complete: () => void emit.end(),
+            });
+            // Ensure we dispose of the query if the running Fiber is terminated.
+            return Effect.sync(dispose);
+        });
+    }
+}

package/dist/effect/index.d.ts

@@ -0,0 +1,7 @@
+export * as Query from './Query.js';
+export * as Subscription from './Subscription.js';
+export * from './QueryClient.js';
+export * as HttpQueryClient from './HttpQueryClient.js';
+export * from './SubscriptionClient.js';
+export * as WsSubscriptionClient from './WsSubscriptionClient.js';
+export * as ConnectionHelper from './ConnectionHelper.js';

package/dist/effect/index.js

@@ -0,0 +1,7 @@
+export * as Query from './Query.js';
+export * as Subscription from './Subscription.js';
+export * from './QueryClient.js';
+export * as HttpQueryClient from './HttpQueryClient.js';
+export * from './SubscriptionClient.js';
+export * as WsSubscriptionClient from './WsSubscriptionClient.js';
+export * as ConnectionHelper from './ConnectionHelper.js';

package/dist/effect/test/httpQueryClient.spied.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/effect/test/httpQueryClient.spied.test.js

@@ -0,0 +1,25 @@
+import { Effect } from 'effect';
+import { describe, expect, it, vi } from 'vitest';
+import * as QueryClient from '../QueryClient.js';
+vi.mock('graphql-http', () => ({
+    createClient: vi.fn(),
+}));
+describe('HttpQueryClient', () => {
+    describe('layer', () => {
+        it('disposes of underlying scoped client', async () => {
+            const graphqlHTTP = await import('graphql-http');
+            const SpiedHttpQueryClient = await import('../HttpQueryClient.js');
+            const dispose = vi.fn();
+            const spiedCreateClient = vi
+                .spyOn(graphqlHTTP, 'createClient')
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-explicit-any
+                .mockImplementationOnce(() => ({ dispose }));
+            await Effect.gen(function* () {
+                const client = yield* QueryClient.QueryClient;
+                expect(client).toBeDefined();
+            }).pipe(Effect.provide(SpiedHttpQueryClient.layer({ url: 'http://localhost.com' })), Effect.scoped, Effect.runPromise);
+            expect(spiedCreateClient).toHaveBeenCalled();
+            expect(dispose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/effect/test/httpQueryClient.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/effect/test/httpQueryClient.test.js

@@ -0,0 +1,20 @@
+import { Effect } from 'effect';
+import { describe, it } from 'vitest';
+import * as QueryClient from '../QueryClient.js';
+import * as HttpQueryClient from '../HttpQueryClient.js';
+describe('HttpQueryClient', () => {
+    describe('layer', () => {
+        // Ensures that we cannot construct a layer for HttpQueryClient when we use common incorrect URI schemes.
+        it.each(['ftp:', 'mailto:', 'ws:', 'wss:', 'file:'])('should fail when constructed with %s as the URI scheme', async (scheme) => {
+            await Effect.gen(function* () {
+                // We should never be able to resolve a QueryClient since the configuration used to create the
+                // associated HttpQueryClient layer is invalid with the protocol schemes being used.
+                return yield* QueryClient.QueryClient;
+            }).pipe(Effect.flatMap((_) => Effect.fail('Unexpectedly resolved a QueryClient')), Effect.provide(HttpQueryClient.layer({ url: `${scheme}//localhost.com` })), 
+            // Ensure the reported invalid protocol scheme is the one used.
+            Effect.catchTag('InvalidProtocolSchemeError', (err) => err.invalidScheme !== scheme
+                ? Effect.fail(`Expected '${scheme}' but received '${err.invalidScheme}'`)
+                : Effect.succeed(void 0)), Effect.scoped, Effect.runPromise);
+        });
+    });
+});

package/dist/effect/test/wsSubscriptionClient.spied.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/effect/test/wsSubscriptionClient.spied.test.js

@@ -0,0 +1,25 @@
+import { Effect } from 'effect';
+import { describe, expect, it, vi } from 'vitest';
+import * as SubscriptionClient from '../SubscriptionClient.js';
+vi.mock('graphql-ws', () => ({
+    createClient: vi.fn(),
+}));
+describe('WsSubscriptionClient', () => {
+    describe('layer', () => {
+        it('disposes of underlying scoped client', async () => {
+            const graphqlWS = await import('graphql-ws');
+            const SpiedWsSubscriptionClient = await import('../WsSubscriptionClient.js');
+            const dispose = vi.fn();
+            const spiedCreateClient = vi
+                .spyOn(graphqlWS, 'createClient')
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-explicit-any
+                .mockImplementationOnce(() => ({ dispose }));
+            await Effect.gen(function* () {
+                const client = yield* SubscriptionClient.SubscriptionClient;
+                expect(client).toBeDefined();
+            }).pipe(Effect.provide(SpiedWsSubscriptionClient.layer({ url: 'ws://localhost.com' })), Effect.scoped, Effect.runPromise);
+            expect(spiedCreateClient).toHaveBeenCalled();
+            expect(dispose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/effect/test/wsSubscriptionClient.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/effect/test/wsSubscriptionClient.test.js

@@ -0,0 +1,20 @@
+import { Effect } from 'effect';
+import { describe, it } from 'vitest';
+import * as SubscriptionClient from '../SubscriptionClient.js';
+import * as WsSubscriptionClient from '../WsSubscriptionClient.js';
+describe('WsSubscriptionClient', () => {
+    describe('layer', () => {
+        // Ensures that we cannot construct a layer for WsSubscriptionClient when we use common incorrect URI schemes.
+        it.each(['ftp:', 'mailto:', 'http:', 'https:', 'file:'])('should fail when constructed with %s as the URI scheme', async (scheme) => {
+            await Effect.gen(function* () {
+                // We should never be able to resolve a SubscriptionClient since the configuration used to create the
+                // associated WsSubscriptionClient layer is invalid with the protocol schemes being used.
+                return yield* SubscriptionClient.SubscriptionClient;
+            }).pipe(Effect.flatMap((_) => Effect.fail('Unexpectedly resolved a SubscriptionClient')), Effect.provide(WsSubscriptionClient.layer({ url: `${scheme}//localhost.com` })), 
+            // Ensure the reported invalid protocol scheme is the one used.
+            Effect.catchTag('InvalidProtocolSchemeError', (err) => err.invalidScheme !== scheme
+                ? Effect.fail(`Expected '${scheme}' but received '${err.invalidScheme}'`)
+                : Effect.succeed(void 0)), Effect.scoped, Effect.runPromise);
+        });
+    });
+});

package/dist/graphql/generated/fragment-masking.d.ts

@@ -0,0 +1,19 @@
+import type { ResultOf, DocumentTypeDecoration, TypedDocumentNode } from '@graphql-typed-document-node/core';
+import type { Incremental } from './graphql.js';
+export type FragmentType<TDocumentType extends DocumentTypeDecoration<any, any>> = TDocumentType extends DocumentTypeDecoration<infer TType, any> ? [TType] extends [{
+    ' $fragmentName'?: infer TKey;
+}] ? TKey extends string ? {
+    ' $fragmentRefs'?: {
+        [key in TKey]: TType;
+    };
+} : never : never : never;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>>): TType;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | undefined): TType | undefined;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | null): TType | null;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | null | undefined): TType | null | undefined;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: Array<FragmentType<DocumentTypeDecoration<TType, any>>>): Array<TType>;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: Array<FragmentType<DocumentTypeDecoration<TType, any>>> | null | undefined): Array<TType> | null | undefined;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>>): ReadonlyArray<TType>;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>> | null | undefined): ReadonlyArray<TType> | null | undefined;
+export declare function makeFragmentData<F extends DocumentTypeDecoration<any, any>, FT extends ResultOf<F>>(data: FT, _fragment: F): FragmentType<F>;
+export declare function isFragmentReady<TQuery, TFrag>(queryNode: DocumentTypeDecoration<TQuery, any>, fragmentNode: TypedDocumentNode<TFrag>, data: FragmentType<TypedDocumentNode<Incremental<TFrag>, any>> | null | undefined): data is FragmentType<typeof fragmentNode>;

package/dist/graphql/generated/fragment-masking.js

@@ -0,0 +1,16 @@
+export function useFragment(_documentNode, fragmentType) {
+    return fragmentType;
+}
+export function makeFragmentData(data, _fragment) {
+    return data;
+}
+export function isFragmentReady(queryNode, fragmentNode, data) {
+    const deferredFields = queryNode.__meta__
+        ?.deferredFields;
+    if (!deferredFields)
+        return true;
+    const fragDef = fragmentNode.definitions[0];
+    const fragName = fragDef?.name?.value;
+    const fields = (fragName && deferredFields[fragName]) || [];
+    return fields.length > 0 && fields.every((field) => data && field in data);
+}

package/dist/graphql/generated/gql.d.ts

@@ -0,0 +1,66 @@
+import * as types from './graphql.js';
+import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
+/**
+ * Map of all GraphQL operations in the project.
+ *
+ * This map has several performance disadvantages:
+ * 1. It is not tree-shakeable, so it will include all operations in the project.
+ * 2. It is not minifiable, so the string of a GraphQL query will be multiple times inside the bundle.
+ * 3. It does not support dead code elimination, so it will add unused operations.
+ *
+ * Therefore it is highly recommended to use the babel or swc plugin for production.
+ * Learn more about it here: https://the-guild.dev/graphql/codegen/plugins/presets/preset-client#reducing-bundle-size
+ */
+type Documents = {
+    '\n    query BlockHash($offset: BlockOffset) {\n      block(offset: $offset) {\n        height\n        hash\n        ledgerParameters\n      }\n    }\n  ': typeof types.BlockHashDocument;
+    '\n    mutation Connect($viewingKey: ViewingKey!) {\n      connect(viewingKey: $viewingKey)\n    }\n  ': typeof types.ConnectDocument;
+    '\n    mutation Disconnect($sessionId: HexEncoded!) {\n      disconnect(sessionId: $sessionId)\n    }\n  ': typeof types.DisconnectDocument;
+    '\n    subscription DustLedgerEvents($id: Int) {\n      dustLedgerEvents(id: $id) {\n        type: __typename\n        id\n        raw\n        maxId\n      }\n    }\n  ': typeof types.DustLedgerEventsDocument;
+    '\n    subscription ShieldedTransactions($sessionId: HexEncoded!, $index: Int) {\n      shieldedTransactions(sessionId: $sessionId, index: $index) {\n        __typename\n        ... on ShieldedTransactionsProgress {\n          highestEndIndex\n          highestCheckedEndIndex\n          highestRelevantEndIndex\n        }\n        ... on RelevantTransaction {\n          transaction {\n            id\n            raw\n            hash\n            protocolVersion\n            identifiers\n            startIndex\n            endIndex\n            fees {\n              paidFees\n              estimatedFees\n            }\n            transactionResult {\n              status\n              segments {\n                id\n                success\n              }\n            }\n          }\n          collapsedMerkleTree {\n            startIndex\n            endIndex\n            update\n            protocolVersion\n          }\n        }\n      }\n    }\n  ': typeof types.ShieldedTransactionsDocument;
+    '\n    subscription UnshieldedTransactions($address: UnshieldedAddress!, $transactionId: Int) {\n      unshieldedTransactions(address: $address, transactionId: $transactionId) {\n        ... on UnshieldedTransaction {\n          type: __typename\n          transaction {\n            type: __typename\n            id\n            hash\n            protocolVersion\n            ... on RegularTransaction {\n              identifiers\n              transactionResult {\n                status\n                segments {\n                  id\n                  success\n                }\n              }\n            }\n          }\n          createdUtxos {\n            owner\n            tokenType\n            value\n            outputIndex\n            intentHash\n            ctime\n            registeredForDustGeneration\n          }\n          spentUtxos {\n            owner\n            tokenType\n            value\n            outputIndex\n            intentHash\n            ctime\n            registeredForDustGeneration\n          }\n        }\n        ... on UnshieldedTransactionsProgress {\n          type: __typename\n          highestTransactionId\n        }\n      }\n    }\n  ': typeof types.UnshieldedTransactionsDocument;
+    '\n    subscription ZswapEvents($id: Int) {\n      zswapLedgerEvents(id: $id) {\n        id\n        raw\n        maxId\n      }\n    }\n  ': typeof types.ZswapEventsDocument;
+};
+declare const documents: Documents;
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ *
+ *
+ * @example
+ * ```ts
+ * const query = gql(`query GetUser($id: ID!) { user(id: $id) { name } }`);
+ * ```
+ *
+ * The query argument is unknown!
+ * Please regenerate the types.
+ */
+export declare function gql(source: string): unknown;
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function gql(source: '\n    query BlockHash($offset: BlockOffset) {\n      block(offset: $offset) {\n        height\n        hash\n        ledgerParameters\n      }\n    }\n  '): (typeof documents)['\n    query BlockHash($offset: BlockOffset) {\n      block(offset: $offset) {\n        height\n        hash\n        ledgerParameters\n      }\n    }\n  '];
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function gql(source: '\n    mutation Connect($viewingKey: ViewingKey!) {\n      connect(viewingKey: $viewingKey)\n    }\n  '): (typeof documents)['\n    mutation Connect($viewingKey: ViewingKey!) {\n      connect(viewingKey: $viewingKey)\n    }\n  '];
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function gql(source: '\n    mutation Disconnect($sessionId: HexEncoded!) {\n      disconnect(sessionId: $sessionId)\n    }\n  '): (typeof documents)['\n    mutation Disconnect($sessionId: HexEncoded!) {\n      disconnect(sessionId: $sessionId)\n    }\n  '];
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function gql(source: '\n    subscription DustLedgerEvents($id: Int) {\n      dustLedgerEvents(id: $id) {\n        type: __typename\n        id\n        raw\n        maxId\n      }\n    }\n  '): (typeof documents)['\n    subscription DustLedgerEvents($id: Int) {\n      dustLedgerEvents(id: $id) {\n        type: __typename\n        id\n        raw\n        maxId\n      }\n    }\n  '];
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function gql(source: '\n    subscription ShieldedTransactions($sessionId: HexEncoded!, $index: Int) {\n      shieldedTransactions(sessionId: $sessionId, index: $index) {\n        __typename\n        ... on ShieldedTransactionsProgress {\n          highestEndIndex\n          highestCheckedEndIndex\n          highestRelevantEndIndex\n        }\n        ... on RelevantTransaction {\n          transaction {\n            id\n            raw\n            hash\n            protocolVersion\n            identifiers\n            startIndex\n            endIndex\n            fees {\n              paidFees\n              estimatedFees\n            }\n            transactionResult {\n              status\n              segments {\n                id\n                success\n              }\n            }\n          }\n          collapsedMerkleTree {\n            startIndex\n            endIndex\n            update\n            protocolVersion\n          }\n        }\n      }\n    }\n  '): (typeof documents)['\n    subscription ShieldedTransactions($sessionId: HexEncoded!, $index: Int) {\n      shieldedTransactions(sessionId: $sessionId, index: $index) {\n        __typename\n        ... on ShieldedTransactionsProgress {\n          highestEndIndex\n          highestCheckedEndIndex\n          highestRelevantEndIndex\n        }\n        ... on RelevantTransaction {\n          transaction {\n            id\n            raw\n            hash\n            protocolVersion\n            identifiers\n            startIndex\n            endIndex\n            fees {\n              paidFees\n              estimatedFees\n            }\n            transactionResult {\n              status\n              segments {\n                id\n                success\n              }\n            }\n          }\n          collapsedMerkleTree {\n            startIndex\n            endIndex\n            update\n            protocolVersion\n          }\n        }\n      }\n    }\n  '];
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function gql(source: '\n    subscription UnshieldedTransactions($address: UnshieldedAddress!, $transactionId: Int) {\n      unshieldedTransactions(address: $address, transactionId: $transactionId) {\n        ... on UnshieldedTransaction {\n          type: __typename\n          transaction {\n            type: __typename\n            id\n            hash\n            protocolVersion\n            ... on RegularTransaction {\n              identifiers\n              transactionResult {\n                status\n                segments {\n                  id\n                  success\n                }\n              }\n            }\n          }\n          createdUtxos {\n            owner\n            tokenType\n            value\n            outputIndex\n            intentHash\n            ctime\n            registeredForDustGeneration\n          }\n          spentUtxos {\n            owner\n            tokenType\n            value\n            outputIndex\n            intentHash\n            ctime\n            registeredForDustGeneration\n          }\n        }\n        ... on UnshieldedTransactionsProgress {\n          type: __typename\n          highestTransactionId\n        }\n      }\n    }\n  '): (typeof documents)['\n    subscription UnshieldedTransactions($address: UnshieldedAddress!, $transactionId: Int) {\n      unshieldedTransactions(address: $address, transactionId: $transactionId) {\n        ... on UnshieldedTransaction {\n          type: __typename\n          transaction {\n            type: __typename\n            id\n            hash\n            protocolVersion\n            ... on RegularTransaction {\n              identifiers\n              transactionResult {\n                status\n                segments {\n                  id\n                  success\n                }\n              }\n            }\n          }\n          createdUtxos {\n            owner\n            tokenType\n            value\n            outputIndex\n            intentHash\n            ctime\n            registeredForDustGeneration\n          }\n          spentUtxos {\n            owner\n            tokenType\n            value\n            outputIndex\n            intentHash\n            ctime\n            registeredForDustGeneration\n          }\n        }\n        ... on UnshieldedTransactionsProgress {\n          type: __typename\n          highestTransactionId\n        }\n      }\n    }\n  '];
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function gql(source: '\n    subscription ZswapEvents($id: Int) {\n      zswapLedgerEvents(id: $id) {\n        id\n        raw\n        maxId\n      }\n    }\n  '): (typeof documents)['\n    subscription ZswapEvents($id: Int) {\n      zswapLedgerEvents(id: $id) {\n        id\n        raw\n        maxId\n      }\n    }\n  '];
+export type DocumentType<TDocumentNode extends DocumentNode<any, any>> = TDocumentNode extends DocumentNode<infer TType, any> ? TType : never;
+export {};

package/dist/graphql/generated/gql.js

@@ -0,0 +1,14 @@
+/* eslint-disable */
+import * as types from './graphql.js';
+const documents = {
+    '\n    query BlockHash($offset: BlockOffset) {\n      block(offset: $offset) {\n        height\n        hash\n        ledgerParameters\n      }\n    }\n  ': types.BlockHashDocument,
+    '\n    mutation Connect($viewingKey: ViewingKey!) {\n      connect(viewingKey: $viewingKey)\n    }\n  ': types.ConnectDocument,
+    '\n    mutation Disconnect($sessionId: HexEncoded!) {\n      disconnect(sessionId: $sessionId)\n    }\n  ': types.DisconnectDocument,
+    '\n    subscription DustLedgerEvents($id: Int) {\n      dustLedgerEvents(id: $id) {\n        type: __typename\n        id\n        raw\n        maxId\n      }\n    }\n  ': types.DustLedgerEventsDocument,
+    '\n    subscription ShieldedTransactions($sessionId: HexEncoded!, $index: Int) {\n      shieldedTransactions(sessionId: $sessionId, index: $index) {\n        __typename\n        ... on ShieldedTransactionsProgress {\n          highestEndIndex\n          highestCheckedEndIndex\n          highestRelevantEndIndex\n        }\n        ... on RelevantTransaction {\n          transaction {\n            id\n            raw\n            hash\n            protocolVersion\n            identifiers\n            startIndex\n            endIndex\n            fees {\n              paidFees\n              estimatedFees\n            }\n            transactionResult {\n              status\n              segments {\n                id\n                success\n              }\n            }\n          }\n          collapsedMerkleTree {\n            startIndex\n            endIndex\n            update\n            protocolVersion\n          }\n        }\n      }\n    }\n  ': types.ShieldedTransactionsDocument,
+    '\n    subscription UnshieldedTransactions($address: UnshieldedAddress!, $transactionId: Int) {\n      unshieldedTransactions(address: $address, transactionId: $transactionId) {\n        ... on UnshieldedTransaction {\n          type: __typename\n          transaction {\n            type: __typename\n            id\n            hash\n            protocolVersion\n            ... on RegularTransaction {\n              identifiers\n              transactionResult {\n                status\n                segments {\n                  id\n                  success\n                }\n              }\n            }\n          }\n          createdUtxos {\n            owner\n            tokenType\n            value\n            outputIndex\n            intentHash\n            ctime\n            registeredForDustGeneration\n          }\n          spentUtxos {\n            owner\n            tokenType\n            value\n            outputIndex\n            intentHash\n            ctime\n            registeredForDustGeneration\n          }\n        }\n        ... on UnshieldedTransactionsProgress {\n          type: __typename\n          highestTransactionId\n        }\n      }\n    }\n  ': types.UnshieldedTransactionsDocument,
+    '\n    subscription ZswapEvents($id: Int) {\n      zswapLedgerEvents(id: $id) {\n        id\n        raw\n        maxId\n      }\n    }\n  ': types.ZswapEventsDocument,
+};
+export function gql(source) {
+    return documents[source] ?? {};
+}