@settlemint/sdk-blockscout 2.3.2-prebafe7cb → 2.3.2-prede7bc05

package/README.md

@@ -50,7 +50,7 @@ The SettleMint Blockscout SDK provides a seamless way to interact with Blockscou
 
 > **createBlockscoutClient**\<`Setup`\>(`options`, `clientOptions?`): `object`
 
-Defined in: [sdk/blockscout/src/blockscout.ts:75](https://github.com/settlemint/sdk/blob/v2.3.2/sdk/blockscout/src/blockscout.ts#L75)
+Defined in: [sdk/blockscout/src/blockscout.ts:76](https://github.com/settlemint/sdk/blob/v2.3.2/sdk/blockscout/src/blockscout.ts#L76)
 
 Creates a Blockscout GraphQL client with proper type safety using gql.tada
 
@@ -64,8 +64,8 @@ Creates a Blockscout GraphQL client with proper type safety using gql.tada
 
 | Parameter | Type | Description |
 | ------ | ------ | ------ |
-| `options` | \{ `accessToken`: `string`; `instance`: `string`; \} | Configuration options for the client |
-| `options.accessToken` | `string` | - |
+| `options` | \{ `accessToken?`: `string`; `instance`: `string`; \} | Configuration options for the client |
+| `options.accessToken?` | `string` | - |
 | `options.instance?` | `string` | - |
 | `clientOptions?` | `RequestConfig` | Optional GraphQL client configuration options |
 
@@ -77,8 +77,8 @@ An object containing the GraphQL client and initialized gql.tada function
 
 | Name | Type | Defined in |
 | ------ | ------ | ------ |
-| `client` | `GraphQLClient` | [sdk/blockscout/src/blockscout.ts:79](https://github.com/settlemint/sdk/blob/v2.3.2/sdk/blockscout/src/blockscout.ts#L79) |
-| `graphql` | `initGraphQLTada`\<`Setup`\> | [sdk/blockscout/src/blockscout.ts:80](https://github.com/settlemint/sdk/blob/v2.3.2/sdk/blockscout/src/blockscout.ts#L80) |
+| `client` | `GraphQLClient` | [sdk/blockscout/src/blockscout.ts:80](https://github.com/settlemint/sdk/blob/v2.3.2/sdk/blockscout/src/blockscout.ts#L80) |
+| `graphql` | `initGraphQLTada`\<`Setup`\> | [sdk/blockscout/src/blockscout.ts:81](https://github.com/settlemint/sdk/blob/v2.3.2/sdk/blockscout/src/blockscout.ts#L81) |
 
 ##### Throws
 
@@ -136,7 +136,7 @@ const result = await client.request(query, {
 
 > **ClientOptions** = `z.infer`\<*typeof* [`ClientOptionsSchema`](#clientoptionsschema)\>
 
-Defined in: [sdk/blockscout/src/blockscout.ts:23](https://github.com/settlemint/sdk/blob/v2.3.2/sdk/blockscout/src/blockscout.ts#L23)
+Defined in: [sdk/blockscout/src/blockscout.ts:24](https://github.com/settlemint/sdk/blob/v2.3.2/sdk/blockscout/src/blockscout.ts#L24)
 
 Type definition for client options derived from the ClientOptionsSchema
 
@@ -146,7 +146,7 @@ Type definition for client options derived from the ClientOptionsSchema
 
 > **RequestConfig** = `ConstructorParameters`\<*typeof* `GraphQLClient`\>\[`1`\]
 
-Defined in: [sdk/blockscout/src/blockscout.ts:10](https://github.com/settlemint/sdk/blob/v2.3.2/sdk/blockscout/src/blockscout.ts#L10)
+Defined in: [sdk/blockscout/src/blockscout.ts:11](https://github.com/settlemint/sdk/blob/v2.3.2/sdk/blockscout/src/blockscout.ts#L11)
 
 Type definition for GraphQL client configuration options
 
@@ -154,9 +154,9 @@ Type definition for GraphQL client configuration options
 
 #### ClientOptionsSchema
 
-> `const` **ClientOptionsSchema**: `ZodObject`\<\{ `accessToken`: `ZodString`; `instance`: `ZodUnion`\<readonly \[`ZodString`, `ZodString`\]\>; \}, `$strip`\>
+> `const` **ClientOptionsSchema**: `ZodObject`\<\{ `accessToken`: `ZodOptional`\<`ZodString`\>; `instance`: `ZodUnion`\<readonly \[`ZodString`, `ZodString`\]\>; \}, `$strip`\>
 
-Defined in: [sdk/blockscout/src/blockscout.ts:15](https://github.com/settlemint/sdk/blob/v2.3.2/sdk/blockscout/src/blockscout.ts#L15)
+Defined in: [sdk/blockscout/src/blockscout.ts:16](https://github.com/settlemint/sdk/blob/v2.3.2/sdk/blockscout/src/blockscout.ts#L16)
 
 Schema for validating client options for the Blockscout client.
 

package/dist/blockscout.cjs

@@ -1,2 +1,112 @@
-"use strict";var p=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var S=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var C=(t,e)=>{for(var r in e)p(t,r,{get:e[r],enumerable:!0})},g=(t,e,r,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of S(e))!d.call(t,o)&&o!==r&&p(t,o,{get:()=>e[o],enumerable:!(n=u(e,o))||n.enumerable});return t};var x=t=>g(p({},"__esModule",{value:!0}),t);var y={};C(y,{ClientOptionsSchema:()=>f,createBlockscoutClient:()=>O,readFragment:()=>h.readFragment});module.exports=x(y);var i=require("@settlemint/sdk-utils/http"),s=require("@settlemint/sdk-utils/runtime"),a=require("@settlemint/sdk-utils/validation"),c=require("gql.tada"),l=require("graphql-request"),m=require("zod/v4"),h=require("gql.tada"),f=m.z.object({instance:a.UrlOrPathSchema,accessToken:a.ApplicationAccessTokenSchema.optional()});function O(t,e){(0,s.ensureServer)();let r=(0,a.validate)(f,t),n=(0,c.initGraphQLTada)(),o=new URL(r.instance).toString();return{client:new l.GraphQLClient(o,{...e,headers:(0,i.appendHeaders)(e?.headers,{"x-auth-token":r.accessToken})}),graphql:n}}0&&(module.exports={ClientOptionsSchema,createBlockscoutClient,readFragment});
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __settlemint_sdk_utils_http = __toESM(require("@settlemint/sdk-utils/http"));
+const __settlemint_sdk_utils_runtime = __toESM(require("@settlemint/sdk-utils/runtime"));
+const __settlemint_sdk_utils_validation = __toESM(require("@settlemint/sdk-utils/validation"));
+const gql_tada = __toESM(require("gql.tada"));
+const graphql_request = __toESM(require("graphql-request"));
+const zod_v4 = __toESM(require("zod/v4"));
+
+//#region src/blockscout.ts
+/**
+* Schema for validating client options for the Blockscout client.
+*/
+const ClientOptionsSchema = zod_v4.z.object({
+	instance: __settlemint_sdk_utils_validation.UrlOrPathSchema,
+	accessToken: __settlemint_sdk_utils_validation.ApplicationAccessTokenSchema.optional()
+});
+/**
+* Creates a Blockscout GraphQL client with proper type safety using gql.tada
+*
+* @param options - Configuration options for the client
+* @param clientOptions - Optional GraphQL client configuration options
+* @returns An object containing the GraphQL client and initialized gql.tada function
+* @throws Will throw an error if the options fail validation
+* @example
+* import { createBlockscoutClient } from '@settlemint/sdk-blockscout';
+* import type { introspection } from "@schemas/blockscout-env";
+* import { createLogger, requestLogger } from '@settlemint/sdk-utils/logging';
+*
+* const logger = createLogger();
+*
+* const { client, graphql } = createBlockscoutClient<{
+*   introspection: introspection;
+*   disableMasking: true;
+*   scalars: {
+*     AddressHash: string;
+*     Data: string;
+*     DateTime: string;
+*     Decimal: string;
+*     FullHash: string;
+*     Json: string;
+*     NonceHash: string;
+*     Wei: string;
+*   };
+* }>({
+*   instance: process.env.SETTLEMINT_BLOCKSCOUT_ENDPOINT,
+*   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN
+* }, {
+*   fetch: requestLogger(logger, "blockscout", fetch) as typeof fetch,
+* });
+*
+* // Making GraphQL queries
+* const query = graphql(`
+*   query GetTransaction($hash: String!) {
+*     transaction(hash: $hash) {
+*       hash
+*       blockNumber
+*       value
+*       gasUsed
+*     }
+*   }
+* `);
+*
+* const result = await client.request(query, {
+*   hash: "0x123abc..."
+* });
+*/
+function createBlockscoutClient(options, clientOptions) {
+	(0, __settlemint_sdk_utils_runtime.ensureServer)();
+	const validatedOptions = (0, __settlemint_sdk_utils_validation.validate)(ClientOptionsSchema, options);
+	const graphql = (0, gql_tada.initGraphQLTada)();
+	const fullUrl = new URL(validatedOptions.instance).toString();
+	return {
+		client: new graphql_request.GraphQLClient(fullUrl, {
+			...clientOptions,
+			headers: (0, __settlemint_sdk_utils_http.appendHeaders)(clientOptions?.headers, { "x-auth-token": validatedOptions.accessToken })
+		}),
+		graphql
+	};
+}
+
+//#endregion
+exports.ClientOptionsSchema = ClientOptionsSchema;
+exports.createBlockscoutClient = createBlockscoutClient;
+Object.defineProperty(exports, 'readFragment', {
+  enumerable: true,
+  get: function () {
+    return gql_tada.readFragment;
+  }
+});
 //# sourceMappingURL=blockscout.cjs.map

package/dist/blockscout.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/blockscout.ts"],"sourcesContent":["import { appendHeaders } from \"@settlemint/sdk-utils/http\";\nimport { ensureServer } from \"@settlemint/sdk-utils/runtime\";\nimport { ApplicationAccessTokenSchema, UrlOrPathSchema, validate } from \"@settlemint/sdk-utils/validation\";\nimport { type AbstractSetupSchema, initGraphQLTada } from \"gql.tada\";\nimport { GraphQLClient } from \"graphql-request\";\nimport { z } from \"zod/v4\";\n\n/**\n * Type definition for GraphQL client configuration options\n */\nexport type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];\n\n/**\n * Schema for validating client options for the Blockscout client.\n */\nexport const ClientOptionsSchema = z.object({\n  instance: UrlOrPathSchema,\n  accessToken: ApplicationAccessTokenSchema.optional(),\n});\n\n/**\n * Type definition for client options derived from the ClientOptionsSchema\n */\nexport type ClientOptions = z.infer<typeof ClientOptionsSchema>;\n\n/**\n * Creates a Blockscout GraphQL client with proper type safety using gql.tada\n *\n * @param options - Configuration options for the client\n * @param clientOptions - Optional GraphQL client configuration options\n * @returns An object containing the GraphQL client and initialized gql.tada function\n * @throws Will throw an error if the options fail validation\n * @example\n * import { createBlockscoutClient } from '@settlemint/sdk-blockscout';\n * import type { introspection } from \"@schemas/blockscout-env\";\n * import { createLogger, requestLogger } from '@settlemint/sdk-utils/logging';\n *\n * const logger = createLogger();\n *\n * const { client, graphql } = createBlockscoutClient<{\n *   introspection: introspection;\n *   disableMasking: true;\n *   scalars: {\n *     AddressHash: string;\n *     Data: string;\n *     DateTime: string;\n *     Decimal: string;\n *     FullHash: string;\n *     Json: string;\n *     NonceHash: string;\n *     Wei: string;\n *   };\n * }>({\n *   instance: process.env.SETTLEMINT_BLOCKSCOUT_ENDPOINT,\n *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN\n * }, {\n *   fetch: requestLogger(logger, \"blockscout\", fetch) as typeof fetch,\n * });\n *\n * // Making GraphQL queries\n * const query = graphql(`\n *   query GetTransaction($hash: String!) {\n *     transaction(hash: $hash) {\n *       hash\n *       blockNumber\n *       value\n *       gasUsed\n *     }\n *   }\n * `);\n *\n * const result = await client.request(query, {\n *   hash: \"0x123abc...\"\n * });\n */\nexport function createBlockscoutClient<const Setup extends AbstractSetupSchema>(\n  options: ClientOptions,\n  clientOptions?: RequestConfig,\n): {\n  client: GraphQLClient;\n  graphql: initGraphQLTada<Setup>;\n} {\n  ensureServer();\n  const validatedOptions = validate(ClientOptionsSchema, options);\n  const graphql = initGraphQLTada<Setup>();\n  const fullUrl = new URL(validatedOptions.instance).toString();\n\n  return {\n    client: new GraphQLClient(fullUrl, {\n      ...clientOptions,\n      headers: appendHeaders(clientOptions?.headers, { \"x-auth-token\": validatedOptions.accessToken }),\n    }),\n    graphql,\n  };\n}\n\nexport { readFragment } from \"gql.tada\";\nexport type { FragmentOf, ResultOf, VariablesOf } from \"gql.tada\";\n"],"mappings":"yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,yBAAAE,EAAA,2BAAAC,EAAA,iDAAAC,EAAAJ,GAAA,IAAAK,EAA8B,sCAC9BC,EAA6B,yCAC7BC,EAAwE,4CACxEC,EAA0D,oBAC1DC,EAA8B,2BAC9BC,EAAkB,kBA2FlBF,EAA6B,oBAjFhBG,EAAsB,IAAE,OAAO,CAC1C,SAAU,kBACV,YAAa,+BAA6B,SAAS,CACrD,CAAC,EAyDM,SAASC,EACdC,EACAC,EAIA,IACA,gBAAa,EACb,IAAMC,KAAmB,YAASJ,EAAqBE,CAAO,EACxDG,KAAU,mBAAuB,EACjCC,EAAU,IAAI,IAAIF,EAAiB,QAAQ,EAAE,SAAS,EAE5D,MAAO,CACL,OAAQ,IAAI,gBAAcE,EAAS,CACjC,GAAGH,EACH,WAAS,iBAAcA,GAAe,QAAS,CAAE,eAAgBC,EAAiB,WAAY,CAAC,CACjG,CAAC,EACD,QAAAC,CACF,CACF","names":["blockscout_exports","__export","ClientOptionsSchema","createBlockscoutClient","__toCommonJS","import_http","import_runtime","import_validation","import_gql","import_graphql_request","import_v4","ClientOptionsSchema","createBlockscoutClient","options","clientOptions","validatedOptions","graphql","fullUrl"]}
+{"version":3,"file":"blockscout.cjs","names":["UrlOrPathSchema","options: ClientOptions","clientOptions?: RequestConfig","GraphQLClient"],"sources":["../src/blockscout.ts"],"sourcesContent":["import { appendHeaders } from \"@settlemint/sdk-utils/http\";\nimport { ensureServer } from \"@settlemint/sdk-utils/runtime\";\nimport { ApplicationAccessTokenSchema, UrlOrPathSchema, validate } from \"@settlemint/sdk-utils/validation\";\nimport { type AbstractSetupSchema, initGraphQLTada } from \"gql.tada\";\nimport { GraphQLClient } from \"graphql-request\";\nimport { z } from \"zod/v4\";\n\n/**\n * Type definition for GraphQL client configuration options\n */\nexport type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];\n\n/**\n * Schema for validating client options for the Blockscout client.\n */\nexport const ClientOptionsSchema = z.object({\n  instance: UrlOrPathSchema,\n  accessToken: ApplicationAccessTokenSchema.optional(),\n});\n\n/**\n * Type definition for client options derived from the ClientOptionsSchema\n */\nexport type ClientOptions = z.infer<typeof ClientOptionsSchema>;\n\n/**\n * Creates a Blockscout GraphQL client with proper type safety using gql.tada\n *\n * @param options - Configuration options for the client\n * @param clientOptions - Optional GraphQL client configuration options\n * @returns An object containing the GraphQL client and initialized gql.tada function\n * @throws Will throw an error if the options fail validation\n * @example\n * import { createBlockscoutClient } from '@settlemint/sdk-blockscout';\n * import type { introspection } from \"@schemas/blockscout-env\";\n * import { createLogger, requestLogger } from '@settlemint/sdk-utils/logging';\n *\n * const logger = createLogger();\n *\n * const { client, graphql } = createBlockscoutClient<{\n *   introspection: introspection;\n *   disableMasking: true;\n *   scalars: {\n *     AddressHash: string;\n *     Data: string;\n *     DateTime: string;\n *     Decimal: string;\n *     FullHash: string;\n *     Json: string;\n *     NonceHash: string;\n *     Wei: string;\n *   };\n * }>({\n *   instance: process.env.SETTLEMINT_BLOCKSCOUT_ENDPOINT,\n *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN\n * }, {\n *   fetch: requestLogger(logger, \"blockscout\", fetch) as typeof fetch,\n * });\n *\n * // Making GraphQL queries\n * const query = graphql(`\n *   query GetTransaction($hash: String!) {\n *     transaction(hash: $hash) {\n *       hash\n *       blockNumber\n *       value\n *       gasUsed\n *     }\n *   }\n * `);\n *\n * const result = await client.request(query, {\n *   hash: \"0x123abc...\"\n * });\n */\nexport function createBlockscoutClient<const Setup extends AbstractSetupSchema>(\n  options: ClientOptions,\n  clientOptions?: RequestConfig,\n): {\n  client: GraphQLClient;\n  graphql: initGraphQLTada<Setup>;\n} {\n  ensureServer();\n  const validatedOptions = validate(ClientOptionsSchema, options);\n  const graphql = initGraphQLTada<Setup>();\n  const fullUrl = new URL(validatedOptions.instance).toString();\n\n  return {\n    client: new GraphQLClient(fullUrl, {\n      ...clientOptions,\n      headers: appendHeaders(clientOptions?.headers, { \"x-auth-token\": validatedOptions.accessToken }),\n    }),\n    graphql,\n  };\n}\n\nexport { readFragment } from \"gql.tada\";\nexport type { FragmentOf, ResultOf, VariablesOf } from \"gql.tada\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeA,MAAa,sBAAsB,SAAE,OAAO;CAC1C,UAAUA;CACV,aAAa,+DAA6B,UAAU;AACrD,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDF,SAAgB,uBACdC,SACAC,eAIA;AACA,mDAAc;CACd,MAAM,mBAAmB,gDAAS,qBAAqB,QAAQ;CAC/D,MAAM,UAAU,+BAAwB;CACxC,MAAM,UAAU,IAAI,IAAI,iBAAiB,UAAU,UAAU;AAE7D,QAAO;EACL,QAAQ,IAAIC,8BAAc,SAAS;GACjC,GAAG;GACH,SAAS,+CAAc,eAAe,SAAS,EAAE,gBAAgB,iBAAiB,YAAa,EAAC;EACjG;EACD;CACD;AACF"}

package/dist/blockscout.d.cts

@@ -1,8 +1,11 @@
-import { AbstractSetupSchema, initGraphQLTada } from 'gql.tada';
-export { FragmentOf, ResultOf, VariablesOf, readFragment } from 'gql.tada';
-import { GraphQLClient } from 'graphql-request';
-import { z } from 'zod/v4';
+import { AbstractSetupSchema, FragmentOf, ResultOf, VariablesOf, initGraphQLTada, readFragment } from "gql.tada";
+import { GraphQLClient } from "graphql-request";
+import { z } from "zod/v4";
 
+//#region src/blockscout.d.ts
+/**
+* Type definition for GraphQL client configuration options
+*/
 /**
  * Type definition for GraphQL client configuration options
  */
@@ -11,8 +14,8 @@ type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];
  * Schema for validating client options for the Blockscout client.
  */
 declare const ClientOptionsSchema: z.ZodObject<{
-    instance: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
-    accessToken: z.ZodOptional<z.ZodString>;
+  instance: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+  accessToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /**
  * Type definition for client options derived from the ClientOptionsSchema
@@ -69,8 +72,10 @@ type ClientOptions = z.infer<typeof ClientOptionsSchema>;
  * });
  */
 declare function createBlockscoutClient<const Setup extends AbstractSetupSchema>(options: ClientOptions, clientOptions?: RequestConfig): {
-    client: GraphQLClient;
-    graphql: initGraphQLTada<Setup>;
+  client: GraphQLClient;
+  graphql: initGraphQLTada<Setup>;
 };
 
-export { type ClientOptions, ClientOptionsSchema, type RequestConfig, createBlockscoutClient };
+//#endregion
+export { ClientOptions, ClientOptionsSchema, FragmentOf, RequestConfig, ResultOf, VariablesOf, createBlockscoutClient, readFragment };
+//# sourceMappingURL=blockscout.d.cts.map

package/dist/blockscout.d.ts

@@ -1,8 +1,11 @@
-import { AbstractSetupSchema, initGraphQLTada } from 'gql.tada';
-export { FragmentOf, ResultOf, VariablesOf, readFragment } from 'gql.tada';
-import { GraphQLClient } from 'graphql-request';
-import { z } from 'zod/v4';
+import { AbstractSetupSchema, FragmentOf, ResultOf, VariablesOf, initGraphQLTada, readFragment } from "gql.tada";
+import { GraphQLClient } from "graphql-request";
+import { z } from "zod/v4";
 
+//#region src/blockscout.d.ts
+/**
+* Type definition for GraphQL client configuration options
+*/
 /**
  * Type definition for GraphQL client configuration options
  */
@@ -11,8 +14,8 @@ type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];
  * Schema for validating client options for the Blockscout client.
  */
 declare const ClientOptionsSchema: z.ZodObject<{
-    instance: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
-    accessToken: z.ZodOptional<z.ZodString>;
+  instance: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+  accessToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /**
  * Type definition for client options derived from the ClientOptionsSchema
@@ -69,8 +72,10 @@ type ClientOptions = z.infer<typeof ClientOptionsSchema>;
  * });
  */
 declare function createBlockscoutClient<const Setup extends AbstractSetupSchema>(options: ClientOptions, clientOptions?: RequestConfig): {
-    client: GraphQLClient;
-    graphql: initGraphQLTada<Setup>;
+  client: GraphQLClient;
+  graphql: initGraphQLTada<Setup>;
 };
 
-export { type ClientOptions, ClientOptionsSchema, type RequestConfig, createBlockscoutClient };
+//#endregion
+export { ClientOptions, ClientOptionsSchema, FragmentOf, RequestConfig, ResultOf, VariablesOf, createBlockscoutClient, readFragment };
+//# sourceMappingURL=blockscout.d.ts.map

package/dist/blockscout.js

@@ -0,0 +1,82 @@
+import { appendHeaders } from "@settlemint/sdk-utils/http";
+import { ensureServer } from "@settlemint/sdk-utils/runtime";
+import { ApplicationAccessTokenSchema, UrlOrPathSchema, validate } from "@settlemint/sdk-utils/validation";
+import { initGraphQLTada, readFragment } from "gql.tada";
+import { GraphQLClient } from "graphql-request";
+import { z } from "zod/v4";
+
+//#region src/blockscout.ts
+/**
+* Schema for validating client options for the Blockscout client.
+*/
+const ClientOptionsSchema = z.object({
+	instance: UrlOrPathSchema,
+	accessToken: ApplicationAccessTokenSchema.optional()
+});
+/**
+* Creates a Blockscout GraphQL client with proper type safety using gql.tada
+*
+* @param options - Configuration options for the client
+* @param clientOptions - Optional GraphQL client configuration options
+* @returns An object containing the GraphQL client and initialized gql.tada function
+* @throws Will throw an error if the options fail validation
+* @example
+* import { createBlockscoutClient } from '@settlemint/sdk-blockscout';
+* import type { introspection } from "@schemas/blockscout-env";
+* import { createLogger, requestLogger } from '@settlemint/sdk-utils/logging';
+*
+* const logger = createLogger();
+*
+* const { client, graphql } = createBlockscoutClient<{
+*   introspection: introspection;
+*   disableMasking: true;
+*   scalars: {
+*     AddressHash: string;
+*     Data: string;
+*     DateTime: string;
+*     Decimal: string;
+*     FullHash: string;
+*     Json: string;
+*     NonceHash: string;
+*     Wei: string;
+*   };
+* }>({
+*   instance: process.env.SETTLEMINT_BLOCKSCOUT_ENDPOINT,
+*   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN
+* }, {
+*   fetch: requestLogger(logger, "blockscout", fetch) as typeof fetch,
+* });
+*
+* // Making GraphQL queries
+* const query = graphql(`
+*   query GetTransaction($hash: String!) {
+*     transaction(hash: $hash) {
+*       hash
+*       blockNumber
+*       value
+*       gasUsed
+*     }
+*   }
+* `);
+*
+* const result = await client.request(query, {
+*   hash: "0x123abc..."
+* });
+*/
+function createBlockscoutClient(options, clientOptions) {
+	ensureServer();
+	const validatedOptions = validate(ClientOptionsSchema, options);
+	const graphql = initGraphQLTada();
+	const fullUrl = new URL(validatedOptions.instance).toString();
+	return {
+		client: new GraphQLClient(fullUrl, {
+			...clientOptions,
+			headers: appendHeaders(clientOptions?.headers, { "x-auth-token": validatedOptions.accessToken })
+		}),
+		graphql
+	};
+}
+
+//#endregion
+export { ClientOptionsSchema, createBlockscoutClient, readFragment };
+//# sourceMappingURL=blockscout.js.map

package/dist/blockscout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockscout.js","names":["options: ClientOptions","clientOptions?: RequestConfig"],"sources":["../src/blockscout.ts"],"sourcesContent":["import { appendHeaders } from \"@settlemint/sdk-utils/http\";\nimport { ensureServer } from \"@settlemint/sdk-utils/runtime\";\nimport { ApplicationAccessTokenSchema, UrlOrPathSchema, validate } from \"@settlemint/sdk-utils/validation\";\nimport { type AbstractSetupSchema, initGraphQLTada } from \"gql.tada\";\nimport { GraphQLClient } from \"graphql-request\";\nimport { z } from \"zod/v4\";\n\n/**\n * Type definition for GraphQL client configuration options\n */\nexport type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];\n\n/**\n * Schema for validating client options for the Blockscout client.\n */\nexport const ClientOptionsSchema = z.object({\n  instance: UrlOrPathSchema,\n  accessToken: ApplicationAccessTokenSchema.optional(),\n});\n\n/**\n * Type definition for client options derived from the ClientOptionsSchema\n */\nexport type ClientOptions = z.infer<typeof ClientOptionsSchema>;\n\n/**\n * Creates a Blockscout GraphQL client with proper type safety using gql.tada\n *\n * @param options - Configuration options for the client\n * @param clientOptions - Optional GraphQL client configuration options\n * @returns An object containing the GraphQL client and initialized gql.tada function\n * @throws Will throw an error if the options fail validation\n * @example\n * import { createBlockscoutClient } from '@settlemint/sdk-blockscout';\n * import type { introspection } from \"@schemas/blockscout-env\";\n * import { createLogger, requestLogger } from '@settlemint/sdk-utils/logging';\n *\n * const logger = createLogger();\n *\n * const { client, graphql } = createBlockscoutClient<{\n *   introspection: introspection;\n *   disableMasking: true;\n *   scalars: {\n *     AddressHash: string;\n *     Data: string;\n *     DateTime: string;\n *     Decimal: string;\n *     FullHash: string;\n *     Json: string;\n *     NonceHash: string;\n *     Wei: string;\n *   };\n * }>({\n *   instance: process.env.SETTLEMINT_BLOCKSCOUT_ENDPOINT,\n *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN\n * }, {\n *   fetch: requestLogger(logger, \"blockscout\", fetch) as typeof fetch,\n * });\n *\n * // Making GraphQL queries\n * const query = graphql(`\n *   query GetTransaction($hash: String!) {\n *     transaction(hash: $hash) {\n *       hash\n *       blockNumber\n *       value\n *       gasUsed\n *     }\n *   }\n * `);\n *\n * const result = await client.request(query, {\n *   hash: \"0x123abc...\"\n * });\n */\nexport function createBlockscoutClient<const Setup extends AbstractSetupSchema>(\n  options: ClientOptions,\n  clientOptions?: RequestConfig,\n): {\n  client: GraphQLClient;\n  graphql: initGraphQLTada<Setup>;\n} {\n  ensureServer();\n  const validatedOptions = validate(ClientOptionsSchema, options);\n  const graphql = initGraphQLTada<Setup>();\n  const fullUrl = new URL(validatedOptions.instance).toString();\n\n  return {\n    client: new GraphQLClient(fullUrl, {\n      ...clientOptions,\n      headers: appendHeaders(clientOptions?.headers, { \"x-auth-token\": validatedOptions.accessToken }),\n    }),\n    graphql,\n  };\n}\n\nexport { readFragment } from \"gql.tada\";\nexport type { FragmentOf, ResultOf, VariablesOf } from \"gql.tada\";\n"],"mappings":";;;;;;;;;;;AAeA,MAAa,sBAAsB,EAAE,OAAO;CAC1C,UAAU;CACV,aAAa,6BAA6B,UAAU;AACrD,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDF,SAAgB,uBACdA,SACAC,eAIA;AACA,eAAc;CACd,MAAM,mBAAmB,SAAS,qBAAqB,QAAQ;CAC/D,MAAM,UAAU,iBAAwB;CACxC,MAAM,UAAU,IAAI,IAAI,iBAAiB,UAAU,UAAU;AAE7D,QAAO;EACL,QAAQ,IAAI,cAAc,SAAS;GACjC,GAAG;GACH,SAAS,cAAc,eAAe,SAAS,EAAE,gBAAgB,iBAAiB,YAAa,EAAC;EACjG;EACD;CACD;AACF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@settlemint/sdk-blockscout",
   "description": "Blockscout integration module for SettleMint SDK, enabling blockchain explorer and analytics functionality",
-  "version": "2.3.2-prebafe7cb",
+  "version": "2.3.2-prede7bc05",
   "type": "module",
   "private": false,
   "license": "FSL-1.1-MIT",
@@ -22,14 +22,14 @@
   },
   "files": ["dist"],
   "main": "./dist/blockscout.cjs",
-  "module": "./dist/blockscout.mjs",
+  "module": "./dist/blockscout.js",
   "types": "./dist/blockscout.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "import": {
         "types": "./dist/blockscout.d.ts",
-        "default": "./dist/blockscout.mjs"
+        "default": "./dist/blockscout.js"
       },
       "require": {
         "types": "./dist/blockscout.d.cts",
@@ -38,8 +38,8 @@
     }
   },
   "scripts": {
-    "build": "tsup-node",
-    "dev": "tsup-node --watch",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
     "publint": "publint run --strict",
     "attw": "attw --pack .",
     "test": "bun test",
@@ -52,7 +52,7 @@
   "devDependencies": {},
   "dependencies": {
     "gql.tada": "^1",
-    "@settlemint/sdk-utils": "2.3.2-prebafe7cb",
+    "@settlemint/sdk-utils": "2.3.2-prede7bc05",
     "graphql-request": "^7",
     "zod": "^3.25.0"
   },

package/dist/blockscout.mjs

@@ -1,2 +0,0 @@
-import{appendHeaders as n}from"@settlemint/sdk-utils/http";import{ensureServer as p}from"@settlemint/sdk-utils/runtime";import{ApplicationAccessTokenSchema as i,UrlOrPathSchema as s,validate as c}from"@settlemint/sdk-utils/validation";import{initGraphQLTada as l}from"gql.tada";import{GraphQLClient as m}from"graphql-request";import{z as f}from"zod/v4";import{readFragment as Q}from"gql.tada";var h=f.object({instance:s,accessToken:i.optional()});function L(r,e){p();let t=c(h,r),o=l(),a=new URL(t.instance).toString();return{client:new m(a,{...e,headers:n(e?.headers,{"x-auth-token":t.accessToken})}),graphql:o}}export{h as ClientOptionsSchema,L as createBlockscoutClient,Q as readFragment};
-//# sourceMappingURL=blockscout.mjs.map

package/dist/blockscout.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/blockscout.ts"],"sourcesContent":["import { appendHeaders } from \"@settlemint/sdk-utils/http\";\nimport { ensureServer } from \"@settlemint/sdk-utils/runtime\";\nimport { ApplicationAccessTokenSchema, UrlOrPathSchema, validate } from \"@settlemint/sdk-utils/validation\";\nimport { type AbstractSetupSchema, initGraphQLTada } from \"gql.tada\";\nimport { GraphQLClient } from \"graphql-request\";\nimport { z } from \"zod/v4\";\n\n/**\n * Type definition for GraphQL client configuration options\n */\nexport type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];\n\n/**\n * Schema for validating client options for the Blockscout client.\n */\nexport const ClientOptionsSchema = z.object({\n  instance: UrlOrPathSchema,\n  accessToken: ApplicationAccessTokenSchema.optional(),\n});\n\n/**\n * Type definition for client options derived from the ClientOptionsSchema\n */\nexport type ClientOptions = z.infer<typeof ClientOptionsSchema>;\n\n/**\n * Creates a Blockscout GraphQL client with proper type safety using gql.tada\n *\n * @param options - Configuration options for the client\n * @param clientOptions - Optional GraphQL client configuration options\n * @returns An object containing the GraphQL client and initialized gql.tada function\n * @throws Will throw an error if the options fail validation\n * @example\n * import { createBlockscoutClient } from '@settlemint/sdk-blockscout';\n * import type { introspection } from \"@schemas/blockscout-env\";\n * import { createLogger, requestLogger } from '@settlemint/sdk-utils/logging';\n *\n * const logger = createLogger();\n *\n * const { client, graphql } = createBlockscoutClient<{\n *   introspection: introspection;\n *   disableMasking: true;\n *   scalars: {\n *     AddressHash: string;\n *     Data: string;\n *     DateTime: string;\n *     Decimal: string;\n *     FullHash: string;\n *     Json: string;\n *     NonceHash: string;\n *     Wei: string;\n *   };\n * }>({\n *   instance: process.env.SETTLEMINT_BLOCKSCOUT_ENDPOINT,\n *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN\n * }, {\n *   fetch: requestLogger(logger, \"blockscout\", fetch) as typeof fetch,\n * });\n *\n * // Making GraphQL queries\n * const query = graphql(`\n *   query GetTransaction($hash: String!) {\n *     transaction(hash: $hash) {\n *       hash\n *       blockNumber\n *       value\n *       gasUsed\n *     }\n *   }\n * `);\n *\n * const result = await client.request(query, {\n *   hash: \"0x123abc...\"\n * });\n */\nexport function createBlockscoutClient<const Setup extends AbstractSetupSchema>(\n  options: ClientOptions,\n  clientOptions?: RequestConfig,\n): {\n  client: GraphQLClient;\n  graphql: initGraphQLTada<Setup>;\n} {\n  ensureServer();\n  const validatedOptions = validate(ClientOptionsSchema, options);\n  const graphql = initGraphQLTada<Setup>();\n  const fullUrl = new URL(validatedOptions.instance).toString();\n\n  return {\n    client: new GraphQLClient(fullUrl, {\n      ...clientOptions,\n      headers: appendHeaders(clientOptions?.headers, { \"x-auth-token\": validatedOptions.accessToken }),\n    }),\n    graphql,\n  };\n}\n\nexport { readFragment } from \"gql.tada\";\nexport type { FragmentOf, ResultOf, VariablesOf } from \"gql.tada\";\n"],"mappings":"AAAA,OAAS,iBAAAA,MAAqB,6BAC9B,OAAS,gBAAAC,MAAoB,gCAC7B,OAAS,gCAAAC,EAA8B,mBAAAC,EAAiB,YAAAC,MAAgB,mCACxE,OAAmC,mBAAAC,MAAuB,WAC1D,OAAS,iBAAAC,MAAqB,kBAC9B,OAAS,KAAAC,MAAS,SA2FlB,OAAS,gBAAAC,MAAoB,WAjFtB,IAAMC,EAAsBF,EAAE,OAAO,CAC1C,SAAUJ,EACV,YAAaD,EAA6B,SAAS,CACrD,CAAC,EAyDM,SAASQ,EACdC,EACAC,EAIA,CACAX,EAAa,EACb,IAAMY,EAAmBT,EAASK,EAAqBE,CAAO,EACxDG,EAAUT,EAAuB,EACjCU,EAAU,IAAI,IAAIF,EAAiB,QAAQ,EAAE,SAAS,EAE5D,MAAO,CACL,OAAQ,IAAIP,EAAcS,EAAS,CACjC,GAAGH,EACH,QAASZ,EAAcY,GAAe,QAAS,CAAE,eAAgBC,EAAiB,WAAY,CAAC,CACjG,CAAC,EACD,QAAAC,CACF,CACF","names":["appendHeaders","ensureServer","ApplicationAccessTokenSchema","UrlOrPathSchema","validate","initGraphQLTada","GraphQLClient","z","readFragment","ClientOptionsSchema","createBlockscoutClient","options","clientOptions","validatedOptions","graphql","fullUrl"]}