glassnode-api 0.1.0

package/README.md

@@ -0,0 +1,74 @@
+# Glassnode API
+
+A Node.js client for the [Glassnode API](https://docs.glassnode.com/).
+
+## Installation
+
+```bash
+yarn add glassnode-api
+```
+
+## Usage
+
+```typescript
+import { GlassnodeAPI } from 'glassnode-api';
+
+// Create an instance with your API key
+const api = new GlassnodeAPI({
+  apiKey: 'YOUR_API_KEY',
+  // Optional: Override the API URL
+  // apiUrl: 'https://api.glassnode.com'
+});
+
+// Fetch asset metadata
+async function getAssets() {
+  try {
+    const response = await api.getAssetMetadata();
+    console.log(response.data);
+  } catch (error) {
+    console.error('Error fetching asset metadata:', error);
+  }
+}
+
+// Fetch metric metadata
+async function getMetrics() {
+  try {
+    const response = await api.getMetricMetadata();
+    console.log(response.data);
+  } catch (error) {
+    console.error('Error fetching metric metadata:', error);
+  }
+}
+```
+
+## Examples
+
+Check the `examples` directory for usage examples. To run the examples:
+
+1. Navigate to the examples directory
+2. Create a `.env` file based on `.env.example` with your API key
+3. Install dependencies with `yarn install`
+4. Run an example with `yarn ts-node metadata.ts`
+
+## Development
+
+```bash
+# Install dependencies
+yarn install
+
+# Build the project
+yarn build
+
+# Run tests
+yarn test
+
+# Lint code
+yarn lint
+
+# Format code
+yarn format
+```
+
+## License
+
+MIT

package/dist/glassnode-api.d.ts

@@ -0,0 +1,45 @@
+import { GlassnodeConfig } from './types/config';
+import { AssetMetadataResponse, MetricMetadataResponse, MetricListResponse } from './types/metadata';
+/**
+ * Glassnode API client
+ */
+export declare class GlassnodeAPI {
+    private apiKey;
+    private apiUrl;
+    /**
+     * Create a new Glassnode API client
+     * @param config Configuration object
+     */
+    constructor(config: GlassnodeConfig);
+    /**
+     * Make an API request
+     * @param endpoint API endpoint path
+     * @param params Query parameters
+     * @returns Promise resolving to the response data
+     */
+    private request;
+    /**
+     * Get metadata for all assets
+     * @returns Promise resolving to validated asset metadata
+     */
+    getAssetMetadata(): Promise<AssetMetadataResponse>;
+    /**
+     * Get metadata for a specific metric
+     * @param metricPath Path of the metric
+     * @param params Queried parameters for the metric
+     * @returns Promise resolving to validated metric metadata
+     */
+    getMetricMetadata(metricPath: string, params?: Record<string, string>): Promise<MetricMetadataResponse>;
+    /**
+     * Get a list of all metrics
+     * @returns Promise resolving to validated metric metadata
+     */
+    getMetricList(): Promise<MetricListResponse>;
+    /**
+     * Call a generic metric
+     * @param metricPath Path of the metric (e.g. /accumulation_balance)
+     * @param params Queried parameters for the metric
+     * @returns Promise resolving to the response data
+     */
+    callMetric<T>(metricPath: string, params?: Record<string, string>): Promise<T>;
+}

package/dist/glassnode-api.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlassnodeAPI = void 0;
+const config_1 = require("./types/config");
+const metadata_1 = require("./types/metadata");
+/**
+ * Glassnode API client
+ */
+class GlassnodeAPI {
+    apiKey;
+    apiUrl;
+    /**
+     * Create a new Glassnode API client
+     * @param config Configuration object
+     */
+    constructor(config) {
+        // Validate config with Zod
+        const validatedConfig = config_1.GlassnodeConfigSchema.parse(config);
+        this.apiKey = validatedConfig.apiKey;
+        this.apiUrl = validatedConfig.apiUrl;
+    }
+    /**
+     * Make an API request
+     * @param endpoint API endpoint path
+     * @param params Query parameters
+     * @returns Promise resolving to the response data
+     */
+    async request(endpoint, params = {}) {
+        // Add API key to params
+        const queryParams = new URLSearchParams({
+            ...params,
+            api_key: this.apiKey,
+        });
+        const url = `${this.apiUrl}${endpoint}?${queryParams}`;
+        try {
+            const response = await fetch(url);
+            if (!response.ok) {
+                if (response.status === 400) {
+                    throw new Error(`Bad request: ${response.statusText}`);
+                }
+                throw new Error(`API request failed with status ${response.status}: ${response.statusText}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Glassnode API error: ${error.message}`);
+            }
+            throw new Error('Unknown error occurred');
+        }
+    }
+    /**
+     * Get metadata for all assets
+     * @returns Promise resolving to validated asset metadata
+     */
+    async getAssetMetadata() {
+        const response = await this.request('/v1/metadata/assets');
+        // Validate response with Zod schema
+        return metadata_1.AssetMetadataResponseSchema.parse(response.data);
+    }
+    /**
+     * Get metadata for a specific metric
+     * @param metricPath Path of the metric
+     * @param params Queried parameters for the metric
+     * @returns Promise resolving to validated metric metadata
+     */
+    async getMetricMetadata(metricPath, params = {}) {
+        const response = await this.request('/v1/metadata/metric', { path: metricPath, ...params });
+        // Validate response with Zod schema
+        return metadata_1.MetricMetadataResponseSchema.parse(response);
+    }
+    /**
+     * Get a list of all metrics
+     * @returns Promise resolving to validated metric metadata
+     */
+    async getMetricList() {
+        const response = await this.request('/v1/metadata/metrics');
+        // Validate response with Zod schema
+        return metadata_1.MetricListResponseSchema.parse(response);
+    }
+    /**
+     * Call a generic metric
+     * @param metricPath Path of the metric (e.g. /accumulation_balance)
+     * @param params Queried parameters for the metric
+     * @returns Promise resolving to the response data
+     */
+    async callMetric(metricPath, params = {}) {
+        const response = await this.request('https://api.glassnode.com/v1/metrics/addresses' + metricPath, params);
+        return response;
+    }
+}
+exports.GlassnodeAPI = GlassnodeAPI;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './glassnode-api';
+export * from './types/config';
+export * from './types/metadata';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./glassnode-api"), exports);
+__exportStar(require("./types/config"), exports);
+__exportStar(require("./types/metadata"), exports);

package/dist/types/config.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+/**
+ * Zod schema for Glassnode API configuration
+ */
+export declare const GlassnodeConfigSchema: z.ZodObject<{
+    /**
+     * API key for authentication
+     */
+    apiKey: z.ZodString;
+    /**
+     * Base URL for the Glassnode API
+     * @default "https://api.glassnode.com"
+     */
+    apiUrl: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    apiKey: string;
+    apiUrl: string;
+}, {
+    apiKey: string;
+    apiUrl?: string | undefined;
+}>;
+/**
+ * Configuration for the Glassnode API client
+ */
+export type GlassnodeConfig = z.input<typeof GlassnodeConfigSchema>;

package/dist/types/config.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlassnodeConfigSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Zod schema for Glassnode API configuration
+ */
+exports.GlassnodeConfigSchema = zod_1.z.object({
+    /**
+     * API key for authentication
+     */
+    apiKey: zod_1.z.string().min(1, 'API key is required'),
+    /**
+     * Base URL for the Glassnode API
+     * @default "https://api.glassnode.com"
+     */
+    apiUrl: zod_1.z.string().url().default('https://api.glassnode.com'),
+});

package/dist/types/metadata.d.ts

@@ -0,0 +1,383 @@
+/**
+ * Metadata response types
+ */
+import { z } from 'zod';
+/**
+ * External identifier sources schema
+ */
+export declare const ExternalIdSourceSchema: z.ZodEnum<["ccdata", "coinmarketcap", "coingecko"]>;
+/**
+ * External identifier sources type
+ */
+export type ExternalIdSource = z.infer<typeof ExternalIdSourceSchema>;
+/**
+ * External identifiers for an asset schema
+ */
+export declare const ExternalIdsSchema: z.ZodRecord<z.ZodEnum<["ccdata", "coinmarketcap", "coingecko"]>, z.ZodOptional<z.ZodString>>;
+/**
+ * External identifiers for an asset type
+ */
+export type ExternalIds = z.infer<typeof ExternalIdsSchema>;
+/**
+ * Blockchain information for an asset schema
+ */
+export declare const AssetBlockchainSchema: z.ZodObject<{
+    /**
+     * Blockchain name
+     */
+    blockchain: z.ZodString;
+    /**
+     * Token address on the blockchain
+     */
+    address: z.ZodString;
+    /**
+     * Number of decimal places
+     */
+    decimals: z.ZodNumber;
+    /**
+     * Whether on-chain metrics are supported
+     */
+    on_chain_support: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    address: string;
+    blockchain: string;
+    decimals: number;
+    on_chain_support: boolean;
+}, {
+    address: string;
+    blockchain: string;
+    decimals: number;
+    on_chain_support: boolean;
+}>;
+/**
+ * Blockchain information for an asset type
+ */
+export type AssetBlockchain = z.infer<typeof AssetBlockchainSchema>;
+/**
+ * Asset metadata schema
+ */
+export declare const AssetMetadataSchema: z.ZodObject<{
+    /**
+     * Asset identifier
+     */
+    id: z.ZodString;
+    /**
+     * Asset symbol (e.g., "BTC", "ETH")
+     */
+    symbol: z.ZodString;
+    /**
+     * Asset name (e.g., "Bitcoin", "Ethereum")
+     */
+    name: z.ZodString;
+    /**
+     * Type of asset (e.g., "coin", "token")
+     */
+    asset_type: z.ZodString;
+    /**
+     * External identifiers for this asset
+     */
+    external_ids: z.ZodRecord<z.ZodEnum<["ccdata", "coinmarketcap", "coingecko"]>, z.ZodOptional<z.ZodString>>;
+    /**
+     * Blockchain information for this asset
+     */
+    blockchains: z.ZodArray<z.ZodObject<{
+        /**
+         * Blockchain name
+         */
+        blockchain: z.ZodString;
+        /**
+         * Token address on the blockchain
+         */
+        address: z.ZodString;
+        /**
+         * Number of decimal places
+         */
+        decimals: z.ZodNumber;
+        /**
+         * Whether on-chain metrics are supported
+         */
+        on_chain_support: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        blockchain: string;
+        decimals: number;
+        on_chain_support: boolean;
+    }, {
+        address: string;
+        blockchain: string;
+        decimals: number;
+        on_chain_support: boolean;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    name: string;
+    id: string;
+    asset_type: string;
+    external_ids: Partial<Record<"ccdata" | "coinmarketcap" | "coingecko", string | undefined>>;
+    blockchains: {
+        address: string;
+        blockchain: string;
+        decimals: number;
+        on_chain_support: boolean;
+    }[];
+}, {
+    symbol: string;
+    name: string;
+    id: string;
+    asset_type: string;
+    external_ids: Partial<Record<"ccdata" | "coinmarketcap" | "coingecko", string | undefined>>;
+    blockchains: {
+        address: string;
+        blockchain: string;
+        decimals: number;
+        on_chain_support: boolean;
+    }[];
+}>;
+/**
+ * Asset metadata type
+ */
+export type AssetMetadata = z.infer<typeof AssetMetadataSchema>;
+/**
+ * Asset metadata response schema
+ */
+export declare const AssetMetadataResponseSchema: z.ZodArray<z.ZodObject<{
+    /**
+     * Asset identifier
+     */
+    id: z.ZodString;
+    /**
+     * Asset symbol (e.g., "BTC", "ETH")
+     */
+    symbol: z.ZodString;
+    /**
+     * Asset name (e.g., "Bitcoin", "Ethereum")
+     */
+    name: z.ZodString;
+    /**
+     * Type of asset (e.g., "coin", "token")
+     */
+    asset_type: z.ZodString;
+    /**
+     * External identifiers for this asset
+     */
+    external_ids: z.ZodRecord<z.ZodEnum<["ccdata", "coinmarketcap", "coingecko"]>, z.ZodOptional<z.ZodString>>;
+    /**
+     * Blockchain information for this asset
+     */
+    blockchains: z.ZodArray<z.ZodObject<{
+        /**
+         * Blockchain name
+         */
+        blockchain: z.ZodString;
+        /**
+         * Token address on the blockchain
+         */
+        address: z.ZodString;
+        /**
+         * Number of decimal places
+         */
+        decimals: z.ZodNumber;
+        /**
+         * Whether on-chain metrics are supported
+         */
+        on_chain_support: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        blockchain: string;
+        decimals: number;
+        on_chain_support: boolean;
+    }, {
+        address: string;
+        blockchain: string;
+        decimals: number;
+        on_chain_support: boolean;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    name: string;
+    id: string;
+    asset_type: string;
+    external_ids: Partial<Record<"ccdata" | "coinmarketcap" | "coingecko", string | undefined>>;
+    blockchains: {
+        address: string;
+        blockchain: string;
+        decimals: number;
+        on_chain_support: boolean;
+    }[];
+}, {
+    symbol: string;
+    name: string;
+    id: string;
+    asset_type: string;
+    external_ids: Partial<Record<"ccdata" | "coinmarketcap" | "coingecko", string | undefined>>;
+    blockchains: {
+        address: string;
+        blockchain: string;
+        decimals: number;
+        on_chain_support: boolean;
+    }[];
+}>, "many">;
+/**
+ * Asset metadata response type
+ */
+export type AssetMetadataResponse = z.infer<typeof AssetMetadataResponseSchema>;
+/**
+ * Metric tier schema
+ */
+export declare const MetricTierSchema: z.ZodEnum<["free", "tier1", "tier2", "tier3", "tier4", "tier5"]>;
+/**
+ * Metric tier type
+ */
+export type MetricTier = z.infer<typeof MetricTierSchema>;
+/**
+ * Metric data type schema
+ */
+export declare const MetricDataTypeSchema: z.ZodEnum<["average", "sum", "count", "percentage", "ratio"]>;
+/**
+ * Metric data type
+ */
+export type MetricDataType = z.infer<typeof MetricDataTypeSchema>;
+/**
+ * Metric metadata schema
+ */
+export declare const MetricMetadataSchema: z.ZodObject<{
+    /**
+     * Metric name
+     */
+    path: z.ZodString;
+    /**
+     * Access tier required for this metric
+     */
+    tier: z.ZodNumber;
+    /**
+     * The last date that the metadata was updated
+     */
+    modified: z.ZodEffects<z.ZodNumber, Date, number>;
+    /**
+     * Next parameter for the metric
+     */
+    next_param: z.ZodOptional<z.ZodString>;
+    /**
+     * Available assets for this metric
+     */
+    refs: z.ZodObject<{
+        docs: z.ZodOptional<z.ZodString>;
+        studio: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        docs?: string | undefined;
+        studio?: string | undefined;
+    }, {
+        docs?: string | undefined;
+        studio?: string | undefined;
+    }>;
+    /**
+     * Queried parameters for the metric
+     */
+    queried: z.ZodRecord<z.ZodString, z.ZodAny>;
+    /**
+     * List of all allowed parameters and their values for the metric
+     */
+    parameters: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    tier: number;
+    modified: Date;
+    refs: {
+        docs?: string | undefined;
+        studio?: string | undefined;
+    };
+    queried: Record<string, any>;
+    parameters: Record<string, string[]>;
+    next_param?: string | undefined;
+}, {
+    path: string;
+    tier: number;
+    modified: number;
+    refs: {
+        docs?: string | undefined;
+        studio?: string | undefined;
+    };
+    queried: Record<string, any>;
+    parameters: Record<string, string[]>;
+    next_param?: string | undefined;
+}>;
+/**
+ * Metric metadata type
+ */
+export type MetricMetadata = z.infer<typeof MetricMetadataSchema>;
+/**
+ * Metric metadata response schema
+ */
+export declare const MetricMetadataResponseSchema: z.ZodObject<{
+    /**
+     * Metric name
+     */
+    path: z.ZodString;
+    /**
+     * Access tier required for this metric
+     */
+    tier: z.ZodNumber;
+    /**
+     * The last date that the metadata was updated
+     */
+    modified: z.ZodEffects<z.ZodNumber, Date, number>;
+    /**
+     * Next parameter for the metric
+     */
+    next_param: z.ZodOptional<z.ZodString>;
+    /**
+     * Available assets for this metric
+     */
+    refs: z.ZodObject<{
+        docs: z.ZodOptional<z.ZodString>;
+        studio: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        docs?: string | undefined;
+        studio?: string | undefined;
+    }, {
+        docs?: string | undefined;
+        studio?: string | undefined;
+    }>;
+    /**
+     * Queried parameters for the metric
+     */
+    queried: z.ZodRecord<z.ZodString, z.ZodAny>;
+    /**
+     * List of all allowed parameters and their values for the metric
+     */
+    parameters: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    tier: number;
+    modified: Date;
+    refs: {
+        docs?: string | undefined;
+        studio?: string | undefined;
+    };
+    queried: Record<string, any>;
+    parameters: Record<string, string[]>;
+    next_param?: string | undefined;
+}, {
+    path: string;
+    tier: number;
+    modified: number;
+    refs: {
+        docs?: string | undefined;
+        studio?: string | undefined;
+    };
+    queried: Record<string, any>;
+    parameters: Record<string, string[]>;
+    next_param?: string | undefined;
+}>;
+/**
+ * Metric list response schema
+ */
+export declare const MetricListResponseSchema: z.ZodArray<z.ZodString, "many">;
+/**
+ * Metric metadata response type
+ */
+export type MetricMetadataResponse = z.infer<typeof MetricMetadataResponseSchema>;
+/**
+ * Metric list response type
+ */
+export type MetricListResponse = z.infer<typeof MetricListResponseSchema>;

package/dist/types/metadata.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricListResponseSchema = exports.MetricMetadataResponseSchema = exports.MetricMetadataSchema = exports.MetricDataTypeSchema = exports.MetricTierSchema = exports.AssetMetadataResponseSchema = exports.AssetMetadataSchema = exports.AssetBlockchainSchema = exports.ExternalIdsSchema = exports.ExternalIdSourceSchema = void 0;
+/**
+ * Metadata response types
+ */
+const zod_1 = require("zod");
+/**
+ * External identifier sources schema
+ */
+exports.ExternalIdSourceSchema = zod_1.z.enum(['ccdata', 'coinmarketcap', 'coingecko']);
+/**
+ * External identifiers for an asset schema
+ */
+exports.ExternalIdsSchema = zod_1.z.record(exports.ExternalIdSourceSchema, zod_1.z.string().optional());
+/**
+ * Blockchain information for an asset schema
+ */
+exports.AssetBlockchainSchema = zod_1.z.object({
+    /**
+     * Blockchain name
+     */
+    blockchain: zod_1.z.string(),
+    /**
+     * Token address on the blockchain
+     */
+    address: zod_1.z.string(),
+    /**
+     * Number of decimal places
+     */
+    decimals: zod_1.z.number().int().nonnegative(),
+    /**
+     * Whether on-chain metrics are supported
+     */
+    on_chain_support: zod_1.z.boolean(),
+});
+/**
+ * Asset metadata schema
+ */
+exports.AssetMetadataSchema = zod_1.z.object({
+    /**
+     * Asset identifier
+     */
+    id: zod_1.z.string(),
+    /**
+     * Asset symbol (e.g., "BTC", "ETH")
+     */
+    symbol: zod_1.z.string(),
+    /**
+     * Asset name (e.g., "Bitcoin", "Ethereum")
+     */
+    name: zod_1.z.string(),
+    /**
+     * Type of asset (e.g., "coin", "token")
+     */
+    asset_type: zod_1.z.string(),
+    /**
+     * External identifiers for this asset
+     */
+    external_ids: exports.ExternalIdsSchema,
+    /**
+     * Blockchain information for this asset
+     */
+    blockchains: zod_1.z.array(exports.AssetBlockchainSchema),
+});
+/**
+ * Asset metadata response schema
+ */
+exports.AssetMetadataResponseSchema = zod_1.z.array(exports.AssetMetadataSchema);
+/**
+ * Metric tier schema
+ */
+exports.MetricTierSchema = zod_1.z.enum(['free', 'tier1', 'tier2', 'tier3', 'tier4', 'tier5']);
+/**
+ * Metric data type schema
+ */
+exports.MetricDataTypeSchema = zod_1.z.enum(['average', 'sum', 'count', 'percentage', 'ratio']);
+/**
+ * Metric metadata schema
+ */
+exports.MetricMetadataSchema = zod_1.z.object({
+    /**
+     * Metric name
+     */
+    path: zod_1.z.string(),
+    /**
+     * Access tier required for this metric
+     */
+    tier: zod_1.z.number().int().nonnegative(),
+    /**
+     * The last date that the metadata was updated
+     */
+    modified: zod_1.z.number().transform((val) => new Date(val * 1000)),
+    /**
+     * Next parameter for the metric
+     */
+    next_param: zod_1.z.string().optional(),
+    /**
+     * Available assets for this metric
+     */
+    refs: zod_1.z.object({
+        docs: zod_1.z.string().optional(),
+        studio: zod_1.z.string().optional(),
+    }),
+    /**
+     * Queried parameters for the metric
+     */
+    queried: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
+    /**
+     * List of all allowed parameters and their values for the metric
+     */
+    parameters: zod_1.z.record(zod_1.z.string(), zod_1.z.array(zod_1.z.string())),
+});
+/**
+ * Metric metadata response schema
+ */
+exports.MetricMetadataResponseSchema = exports.MetricMetadataSchema;
+/**
+ * Metric list response schema
+ */
+exports.MetricListResponseSchema = zod_1.z.array(zod_1.z.string().startsWith('/'));

package/dist/types/response.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+/**
+ * Generic API response schema
+ */
+export declare const ResponseSchema: <T extends z.ZodTypeAny>(dataSchema: T) => z.ZodObject<{
+    /**
+     * Response data
+     */
+    data: T;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    /**
+     * Response data
+     */
+    data: T;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    /**
+     * Response data
+     */
+    data: T;
+}>, any>[k]; } : never, z.baseObjectInputType<{
+    /**
+     * Response data
+     */
+    data: T;
+}> extends infer T_2 ? { [k_1 in keyof T_2]: z.baseObjectInputType<{
+    /**
+     * Response data
+     */
+    data: T;
+}>[k_1]; } : never>;
+/**
+ * Generic API response type
+ */
+export type Response<T> = {
+    /**
+     * Response data
+     */
+    data: T;
+};

package/dist/types/response.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Generic API response schema
+ */
+const ResponseSchema = (dataSchema) => zod_1.z.object({
+    /**
+     * Response data
+     */
+    data: dataSchema
+});
+exports.ResponseSchema = ResponseSchema;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "glassnode-api",
+  "version": "0.1.0",
+  "description": "Node.js client for the Glassnode API",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "prepare": "husky",
+    "prepublishOnly": "npm run build",
+    "preversion": "npm run lint",
+    "version": "npm run format && git add -A src",
+    "postversion": "git push && git push --tags"
+  },
+  "author": "Jordi Planadecursach",
+  "license": "MIT",
+  "dependencies": {
+    "zod": "^3.24.4"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.26.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.15.17",
+    "eslint": "^9.26.0",
+    "husky": "^9.1.7",
+    "jest": "^29.7.0",
+    "lint-staged": "^16.0.0",
+    "prettier": "^3.5.3",
+    "ts-jest": "^29.3.2",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.32.0"
+  },
+  "lint-staged": {
+    "*.{js,ts,mjs}": [
+      "eslint --fix",
+      "prettier --write",
+      "jest --findRelatedTests --passWithNoTests"
+    ]
+  },
+  "module": "NodeNext"
+}