npm - @zerohash-sdk/fiat-deposits-js - Versions diffs - 1.1.0 - Mend

@zerohash-sdk/fiat-deposits-js 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/README.md ADDED Viewed

@@ -0,0 +1,118 @@
+# @zerohash-sdk/fiat-deposits-js
+A JavaScript SDK that enables frontend applications to seamlessly integrate with the Connect Fiat Deposits product.
+Connect Fiat Deposits provides a secure, customizable flow for depositing fiat currency directly within your application.
+## Installation
+### Via NPM (recommended)
+```bash
+npm install @zerohash-sdk/fiat-deposits-js
+```
+```javascript
+import { FiatDeposits } from '@zerohash-sdk/fiat-deposits-js';
+```
+### Via CDN
+```html
+<script
+  type="module"
+  src="https://sdk.connect.xyz/fiat-deposits-web/index.js"
+></script>
+```
+Or import directly in your JavaScript code:
+```javascript
+import { FiatDeposits } from 'https://sdk.connect.xyz/fiat-deposits-web/index.js';
+```
+## Getting Started
+### 1. Import the FiatDeposits module
+```javascript
+import { FiatDeposits } from '@zerohash-sdk/fiat-deposits-js';
+```
+### 2. Initialize and render the widget
+```javascript
+const fiatDeposits = new FiatDeposits({
+  jwt: 'your-jwt-token',
+  env: 'prod',
+  theme: 'auto',
+  onCompleted: ({ amountDeposited, assetSymbol }) => {
+    console.log('Deposit completed:', amountDeposited, assetSymbol);
+  },
+  onError: ({ errorCode, reason }) => {
+    console.error('Error:', errorCode, 'Reason:', reason);
+  },
+  onClose: () => console.log('Widget closed'),
+  onEvent: ({ type, data }) => console.log('Event:', type, data),
+  onLoaded: () => console.log('Widget loaded and ready'),
+});
+await fiatDeposits.render(document.getElementById('fiat-deposits-container'));
+fiatDeposits.destroy();
+```
+### 2.1 Using TypeScript (optional)
+```typescript
+import { FiatDeposits, FiatDepositsConfig } from '@zerohash-sdk/fiat-deposits-js';
+const config: FiatDepositsConfig = {
+  jwt: 'your-jwt-token',
+  env: 'cert',
+  onCompleted: ({ amountDeposited, assetSymbol }) => {
+    console.log(amountDeposited, assetSymbol);
+  },
+};
+const fiatDeposits = new FiatDeposits(config);
+await fiatDeposits.render(document.getElementById('container')!);
+```
+## API Reference
+### Configuration
+| Prop          | Type                                         | Required | Default  | Description                                           |
+| ------------- | -------------------------------------------- | -------- | -------- | ----------------------------------------------------- |
+| `jwt`         | `string`                                     | Yes      | -        | JWT token for authentication with Connect             |
+| `env`         | `"prod" \| "cert" \| "dev" \| "local"`       | No       | `"prod"` | Target environment                                    |
+| `theme`       | `"auto" \| "light" \| "dark"`                | No       | `"auto"` | Theme mode for the interface                          |
+| `onCompleted` | `({ amountDeposited, assetSymbol }) => void` | No       | -        | Callback when the deposit flow completes successfully |
+| `onError`     | `({ errorCode, reason }) => void`            | No       | -        | Callback for error events                             |
+| `onClose`     | `() => void`                                 | No       | -        | Callback when the widget is closed                    |
+| `onEvent`     | `({ type, data }) => void`                   | No       | -        | Callback for general events                           |
+| `onLoaded`    | `() => void`                                 | No       | -        | Callback when the widget is loaded and ready          |
+### Methods
+#### `render(container: HTMLElement): Promise<void>`
+#### `updateConfig(config: Partial<FiatDepositsConfig>): void`
+#### `destroy(): void`
+#### `isRendered(): boolean`
+#### `getConfig(): FiatDepositsConfig`
+## Browser Support
+- Chrome/Edge 90+
+- Firefox 88+
+- Safari 14+
+- All modern browsers with Web Components support
+## More Information & Support
+For comprehensive documentation or support about Connect, visit our [Documentation Page](https://docs.zerohash.com/).

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,463 @@
+/**
+ * Generic app event structure
+ * @template TType - Event type string
+ * @template TData - Event data payload
+ */
+declare type AppEvent<TType extends string = string, TData = Record<string, unknown>> = {
+    /** The type of event that occurred */
+    type: TType;
+    /** Data associated with the event */
+    data: TData;
+};
+/**
+ * Configuration options for the SDK
+ */
+declare interface BaseConfig<TEvent = AppEvent> extends CommonCallbacks<TEvent> {
+    /**
+     * JWT token used for authentication
+     */
+    jwt: string;
+    /**
+     * Target environment
+     * @default 'production'
+     */
+    env?: Environment;
+    /**
+     * Theme mode
+     * @default 'auto'
+     *
+     * Available themes:
+     * - `'auto'` - Automatically detect system preference (light/dark mode)
+     * - `'light'` - Force light theme
+     * - `'dark'` - Force dark theme
+     */
+    theme?: Theme;
+}
+declare type BaseErrorMessageKeys =
+| 'ALREADY_RENDERED'
+| 'NOT_RENDERED'
+| 'INVALID_CONTAINER'
+| 'SCRIPT_LOAD_FAILED'
+| 'WEB_COMPONENT_NOT_DEFINED';
+declare abstract class BaseJsSdk<Config extends BaseConfig<never> = BaseConfig> {
+    private config: Config;
+    private state: SdkState;
+    private scriptLoadingPromise?: Promise<void>;
+    protected abstract errorMessages: Record<BaseErrorMessageKeys, string>;
+    protected abstract scriptUrls: Record<string, string>;
+    protected abstract webComponentTag: string;
+    constructor(config: Config) {
+        if (!config.jwt || typeof config.jwt !== 'string') {
+            throw new Error(INVALID_JWT_ERROR_MESSAGE);
+        }
+        this.config = {
+            ...config,
+            env: config.env || DEFAULT_ENVIRONMENT,
+            theme: config.theme,
+        };
+        this.state = {
+            initialized: false,
+            scriptLoaded: false,
+            container: null,
+            element: null,
+        };
+    }
+    /**
+     * Render the widget to a container element
+     * @param container - The container element to render the widget into
+     * @returns Promise that resolves when the widget is rendered
+     */
+    async render(container: HTMLElement): Promise<void> {
+        // Validate container
+        if (!container || !(container instanceof HTMLElement)) {
+            throw new Error(this.errorMessages.INVALID_CONTAINER);
+        }
+        // Check if already rendered
+        if (this.state.initialized) {
+            throw new Error(this.errorMessages.ALREADY_RENDERED);
+        }
+        try {
+            // Ensure script is loaded
+            await this.ensureScriptLoaded();
+            // Create and append the web component
+            const element = this.createWebComponent();
+            // Clear the container and append the element
+            container.innerHTML = '';
+            container.appendChild(element);
+            // Update state
+            this.state.container = container;
+            this.state.element = element;
+            this.state.initialized = true;
+        } catch (error) {
+            console.error('Failed to render widget:', error);
+            throw error;
+        }
+    }
+    /**
+     * Update the configuration of the widget
+     * @param config - Partial configuration to update
+     * @returns void
+     */
+    updateConfig(config: Partial<Config>): void {
+        if (!this.state.initialized || !this.state.element) {
+            throw new Error(this.errorMessages.NOT_RENDERED);
+        }
+        const element = this.state.element as SdkElement<Config>;
+        Object.entries(config).forEach(([key, value]) => {
+            if (value) {
+                this.config[key as keyof Config] = value;
+                element[key as keyof Config] = value;
+            }
+        });
+    }
+    /**
+     * Destroy the widget and clean up resources
+     */
+    destroy(): void {
+        if (!this.state.initialized) {
+            return; // Nothing to destroy
+        }
+        // Remove the element from the container
+        if (this.state.element && this.state.element.parentNode) {
+            this.state.element.parentNode.removeChild(this.state.element);
+        }
+        // Clear the container
+        if (this.state.container) {
+            this.state.container.innerHTML = '';
+        }
+        // Reset state
+        this.state.container = null;
+        this.state.element = null;
+        this.state.initialized = false;
+    }
+    /**
+     * Check if the widget is currently rendered
+     * @returns True if the widget is rendered, false otherwise
+     */
+    isRendered(): boolean {
+        return this.state.initialized;
+    }
+    /**
+     * Get the current configuration
+     * @returns The current configuration object
+     */
+    getConfig(): Readonly<Config> {
+        return { ...this.config };
+    }
+    private getEnvironment(): Environment {
+        return this.config.env || DEFAULT_ENVIRONMENT;
+    }
+    private getScriptId() {
+        return `${this.webComponentTag}-script-${this.getEnvironment()}`;
+    }
+    private isScriptLoaded() {
+        return !!document.getElementById(this.getScriptId());
+    }
+    private getWebComponent() {
+        return customElements.get(this.webComponentTag);
+    }
+    private getScriptUrl() {
+        // Support local development with Vite
+        if (typeof import.meta !== 'undefined' && import.meta.env?.['VITE_INTERNAL_BUILD'] === 'true') {
+            return import.meta.env['VITE_SCRIPT_URL'] || this.scriptUrls[this.getEnvironment()];
+        }
+        return this.scriptUrls[this.getEnvironment()];
+    }
+    private async loadScript() {
+        if (this.isScriptLoaded()) {
+            return;
+        }
+        if (this.scriptLoadingPromise) {
+            return this.scriptLoadingPromise;
+        }
+        this.scriptLoadingPromise = new Promise<void>((resolve, reject) => {
+            const script = document.createElement('script');
+            script.id = this.getScriptId();
+            script.src = this.getScriptUrl();
+            script.type = 'module';
+            script.async = true;
+            script.onload = () => {
+                setTimeout(() => {
+                    if (this.getWebComponent()) {
+                        resolve();
+                    } else {
+                        reject(new Error(this.errorMessages.WEB_COMPONENT_NOT_DEFINED));
+                    }
+                }, 0);
+            };
+            script.onerror = () => {
+                this.scriptLoadingPromise = undefined;
+                reject(new Error(`${this.errorMessages.SCRIPT_LOAD_FAILED} (${this.getEnvironment()})`));
+            };
+            document.head.appendChild(script);
+        });
+        try {
+            await this.scriptLoadingPromise;
+        } catch (error) {
+            this.scriptLoadingPromise = undefined;
+            throw error;
+        }
+        return this.scriptLoadingPromise;
+    }
+    private async waitForWebComponent(timeout = 5000) {
+        if (this.getWebComponent()) {
+            return;
+        }
+        return new Promise<void>((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error(`Timeout waiting for ${this.webComponentTag} to be defined`));
+            }, timeout);
+            customElements
+            .whenDefined(this.webComponentTag)
+            .then(() => {
+                clearTimeout(timeoutId);
+                resolve();
+            })
+            .catch((error) => {
+                clearTimeout(timeoutId);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Load the web component script if not already loaded
+     */
+    protected async ensureScriptLoaded(): Promise<void> {
+        if (this.state.scriptLoaded) {
+            return;
+        }
+        try {
+            await this.loadScript();
+            await this.waitForWebComponent();
+            this.state.scriptLoaded = true;
+        } catch (error) {
+            console.error('Failed to load Connect script:', error);
+            throw error;
+        }
+    }
+    private createWebComponent() {
+        const element = document.createElement(this.webComponentTag) as SdkElement<Config>;
+        Object.entries(this.config).forEach(([key, value]) => {
+            if (value) {
+                element[key as keyof Config] = value;
+            }
+        });
+        return element;
+    }
+}
+/**
+ * Common callback function types shared across all Connect apps
+ * @template TEvent - The event type for onEvent callback
+ */
+declare type CommonCallbacks<TEvent = AppEvent> = {
+    /** Called when an error occurs */
+    onError?: (error: ErrorPayload) => void;
+    /** Called when the component is closed */
+    onClose?: () => void;
+    /** Called when a general event occurs */
+    onEvent?: (event: TEvent) => void;
+    /** Called when the widget has loaded and is ready */
+    onLoaded?: () => void;
+};
+export declare type ConnectFiatDepositsElement = SdkElement<FiatDepositsConfig>;
+/**
+ * Environment configuration for the SDK
+ */
+declare type Environment = 'local' | 'dev' | 'cert' | 'prod' | 'sandbox' | 'production';
+/**
+ * Generic error codes for all Connect applications
+ */
+declare enum ErrorCode {
+    /** Network connectivity error */
+    NETWORK_ERROR = 'network_error',
+    /** Authentication or session expired error */
+    AUTH_ERROR = 'auth_error',
+    /** Resource not found error */
+    NOT_FOUND_ERROR = 'not_found_error',
+    /** Validation error from user input */
+    VALIDATION_ERROR = 'validation_error',
+    /** Server error (5xx) */
+    SERVER_ERROR = 'server_error',
+    /** Client error (4xx) */
+    CLIENT_ERROR = 'client_error',
+    /** Unknown or unexpected error */
+    UNKNOWN_ERROR = 'unknown_error',
+}
+/**
+ * Generic error payload structure for error callbacks
+ */
+declare type ErrorPayload = {
+    /** Error code indicating the type of error */
+    errorCode: ErrorCode;
+    /** Human-readable reason for the error */
+    reason: string;
+};
+/**
+ * FiatDeposits SDK class for programmatic control of the Connect Fiat Deposits widget.
+ *
+ * Renders the `zerohash-fiat-deposits` web component, which handles the iframe
+ * and postMessage communication internally.
+ *
+ * @example
+ * ```javascript
+ * const fiatDeposits = new FiatDeposits({
+ *   jwt: 'your-jwt-token',
+ *   env: 'prod',
+ *   theme: 'auto',
+ *   onCompleted: ({ amountDeposited }) => console.log('Deposited', amountDeposited),
+ *   onClose: () => console.log('Closed'),
+ *   onError: ({ errorCode, reason }) => console.error(errorCode, reason),
+ * });
+ *
+ * // Render to a container
+ * await fiatDeposits.render(document.getElementById('fiat-deposits-container'));
+ *
+ * // Update configuration
+ * fiatDeposits.updateConfig({ jwt: 'new-token', theme: 'dark' });
+ *
+ * // Clean up
+ * fiatDeposits.destroy();
+ * ```
+ */
+export declare class FiatDeposits extends BaseJsSdk<FiatDepositsConfig> {
+    protected errorMessages: {
+        ALREADY_RENDERED: string;
+        NOT_RENDERED: string;
+        INVALID_CONTAINER: string;
+        SCRIPT_LOAD_FAILED: string;
+        WEB_COMPONENT_NOT_DEFINED: string;
+    };
+    protected scriptUrls: {
+        local: string;
+        dev: string;
+        cert: string;
+        prod: string;
+        sandbox: string;
+        production: string;
+    };
+    protected webComponentTag: string;
+    /**
+     * Render the FiatDeposits widget to a container element
+     * @param container - The container element to render the widget into
+     * @returns Promise that resolves when the widget is rendered
+     */
+    render(container: HTMLElement): Promise<void>;
+    /**
+     * Update the configuration of the FiatDeposits widget
+     * @param config - Partial configuration to update
+     */
+    updateConfig(config: Partial<FiatDepositsConfig>): void;
+    /**
+     * Get the current configuration
+     * @returns The current configuration object
+     */
+    getConfig(): Readonly<FiatDepositsConfig>;
+    /**
+     * Check if the FiatDeposits widget is currently rendered
+     * @returns True if the widget is rendered, false otherwise
+     */
+    isRendered(): boolean;
+    /**
+     * Destroy the FiatDeposits widget and clean up resources
+     */
+    destroy(): void;
+}
+declare type FiatDepositsCallbacks = CommonCallbacks<FiatDepositsEvent> & {
+    /** Called when the flow is successfully completed */
+    onCompleted?: (data: FiatDepositsCompletedData) => void;
+};
+declare type FiatDepositsCompletedData = {
+    amountDeposited: string;
+    assetSymbol: string;
+};
+export declare interface FiatDepositsConfig extends BaseConfig<FiatDepositsEvent>, FiatDepositsCallbacks {
+}
+declare type FiatDepositsEvent = AppEvent<FiatDepositsEventType>;
+declare type FiatDepositsEventType = string;
+/**
+ * Generic HTMLElement representing a web component with custom config
+ */
+declare type SdkElement<Config extends BaseConfig<never>> = HTMLElement & Config;
+/**
+ * Internal state of the SDK
+ */
+declare interface SdkState {
+    /** Whether the SDK is initialized */
+    initialized: boolean;
+    /** Whether the web component script is loaded */
+    scriptLoaded: boolean;
+    /** The container element where the widget is rendered */
+    container: HTMLElement | null;
+    /** The web component element */
+    element: HTMLElement | null;
+}
+/**
+ * Theme configuration for the SDK
+ *
+ * - `"auto"` - Automatically detect system preference (light/dark mode)
+ * - `"light"` - Force light theme
+ * - `"dark"` - Force dark theme
+ */
+declare type Theme = 'auto' | 'light' | 'dark';
+export { }

package/dist/index.js ADDED Viewed

@@ -0,0 +1,198 @@
+const n = "production", d = "JWT token is required and must be a string.";
+class c {
+  config;
+  state;
+  scriptLoadingPromise;
+  constructor(e) {
+    if (!e.jwt || typeof e.jwt != "string")
+      throw new Error(d);
+    this.config = {
+      ...e,
+      env: e.env || n,
+      theme: e.theme
+    }, this.state = {
+      initialized: !1,
+      scriptLoaded: !1,
+      container: null,
+      element: null
+    };
+  }
+  /**
+   * Render the widget to a container element
+   * @param container - The container element to render the widget into
+   * @returns Promise that resolves when the widget is rendered
+   */
+  async render(e) {
+    if (!e || !(e instanceof HTMLElement))
+      throw new Error(this.errorMessages.INVALID_CONTAINER);
+    if (this.state.initialized)
+      throw new Error(this.errorMessages.ALREADY_RENDERED);
+    try {
+      await this.ensureScriptLoaded();
+      const i = this.createWebComponent();
+      e.innerHTML = "", e.appendChild(i), this.state.container = e, this.state.element = i, this.state.initialized = !0;
+    } catch (i) {
+      throw console.error("Failed to render widget:", i), i;
+    }
+  }
+  /**
+   * Update the configuration of the widget
+   * @param config - Partial configuration to update
+   * @returns void
+   */
+  updateConfig(e) {
+    if (!this.state.initialized || !this.state.element)
+      throw new Error(this.errorMessages.NOT_RENDERED);
+    const i = this.state.element;
+    Object.entries(e).forEach(([t, s]) => {
+      s && (this.config[t] = s, i[t] = s);
+    });
+  }
+  /**
+   * Destroy the widget and clean up resources
+   */
+  destroy() {
+    this.state.initialized && (this.state.element && this.state.element.parentNode && this.state.element.parentNode.removeChild(this.state.element), this.state.container && (this.state.container.innerHTML = ""), this.state.container = null, this.state.element = null, this.state.initialized = !1);
+  }
+  /**
+   * Check if the widget is currently rendered
+   * @returns True if the widget is rendered, false otherwise
+   */
+  isRendered() {
+    return this.state.initialized;
+  }
+  /**
+   * Get the current configuration
+   * @returns The current configuration object
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  getEnvironment() {
+    return this.config.env || n;
+  }
+  getScriptId() {
+    return `${this.webComponentTag}-script-${this.getEnvironment()}`;
+  }
+  isScriptLoaded() {
+    return !!document.getElementById(this.getScriptId());
+  }
+  getWebComponent() {
+    return customElements.get(this.webComponentTag);
+  }
+  getScriptUrl() {
+    return this.scriptUrls[this.getEnvironment()];
+  }
+  async loadScript() {
+    if (!this.isScriptLoaded()) {
+      if (this.scriptLoadingPromise)
+        return this.scriptLoadingPromise;
+      this.scriptLoadingPromise = new Promise((e, i) => {
+        const t = document.createElement("script");
+        t.id = this.getScriptId(), t.src = this.getScriptUrl(), t.type = "module", t.async = !0, t.onload = () => {
+          setTimeout(() => {
+            this.getWebComponent() ? e() : i(new Error(this.errorMessages.WEB_COMPONENT_NOT_DEFINED));
+          }, 0);
+        }, t.onerror = () => {
+          this.scriptLoadingPromise = void 0, i(new Error(`${this.errorMessages.SCRIPT_LOAD_FAILED} (${this.getEnvironment()})`));
+        }, document.head.appendChild(t);
+      });
+      try {
+        await this.scriptLoadingPromise;
+      } catch (e) {
+        throw this.scriptLoadingPromise = void 0, e;
+      }
+      return this.scriptLoadingPromise;
+    }
+  }
+  async waitForWebComponent(e = 5e3) {
+    if (!this.getWebComponent())
+      return new Promise((i, t) => {
+        const s = setTimeout(() => {
+          t(new Error(`Timeout waiting for ${this.webComponentTag} to be defined`));
+        }, e);
+        customElements.whenDefined(this.webComponentTag).then(() => {
+          clearTimeout(s), i();
+        }).catch((a) => {
+          clearTimeout(s), t(a);
+        });
+      });
+  }
+  /**
+   * Load the web component script if not already loaded
+   */
+  async ensureScriptLoaded() {
+    if (!this.state.scriptLoaded)
+      try {
+        await this.loadScript(), await this.waitForWebComponent(), this.state.scriptLoaded = !0;
+      } catch (e) {
+        throw console.error("Failed to load Connect script:", e), e;
+      }
+  }
+  createWebComponent() {
+    const e = document.createElement(this.webComponentTag);
+    return Object.entries(this.config).forEach(([i, t]) => {
+      t && (e[i] = t);
+    }), e;
+  }
+}
+var o;
+(function(r) {
+  r.NETWORK_ERROR = "network_error", r.AUTH_ERROR = "auth_error", r.NOT_FOUND_ERROR = "not_found_error", r.VALIDATION_ERROR = "validation_error", r.SERVER_ERROR = "server_error", r.CLIENT_ERROR = "client_error", r.UNKNOWN_ERROR = "unknown_error";
+})(o || (o = {}));
+class h extends c {
+  errorMessages = {
+    ALREADY_RENDERED: "FiatDeposits widget is already rendered. Call destroy() before rendering again.",
+    NOT_RENDERED: "FiatDeposits widget is not rendered. Call render() first.",
+    INVALID_CONTAINER: "Invalid container element provided.",
+    SCRIPT_LOAD_FAILED: "Failed to load the Connect FiatDeposits script.",
+    WEB_COMPONENT_NOT_DEFINED: "Web component is not defined. Script may not be loaded."
+  };
+  scriptUrls = {
+    local: "http://localhost:5173/fiat-deposits-web/index.js",
+    dev: "https://connect-sdk.dev.0hash.com/fiat-deposits-web/index.js",
+    cert: "https://sdk.sandbox.connect.xyz/fiat-deposits-web/index.js",
+    prod: "https://sdk.connect.xyz/fiat-deposits-web/index.js",
+    sandbox: "https://sdk.sandbox.connect.xyz/fiat-deposits-web/index.js",
+    production: "https://sdk.connect.xyz/fiat-deposits-web/index.js"
+  };
+  webComponentTag = "zerohash-fiat-deposits";
+  /**
+   * Render the FiatDeposits widget to a container element
+   * @param container - The container element to render the widget into
+   * @returns Promise that resolves when the widget is rendered
+   */
+  render(e) {
+    return super.render(e);
+  }
+  /**
+   * Update the configuration of the FiatDeposits widget
+   * @param config - Partial configuration to update
+   */
+  updateConfig(e) {
+    return super.updateConfig(e);
+  }
+  /**
+   * Get the current configuration
+   * @returns The current configuration object
+   */
+  getConfig() {
+    return super.getConfig();
+  }
+  /**
+   * Check if the FiatDeposits widget is currently rendered
+   * @returns True if the widget is rendered, false otherwise
+   */
+  isRendered() {
+    return super.isRendered();
+  }
+  /**
+   * Destroy the FiatDeposits widget and clean up resources
+   */
+  destroy() {
+    return super.destroy();
+  }
+}
+export {
+  h as FiatDeposits
+};

package/dist/index.umd.cjs ADDED Viewed

@@ -0,0 +1 @@

package/package.json ADDED Viewed

@@ -0,0 +1,25 @@
+{
+  "name": "@zerohash-sdk/fiat-deposits-js",
+  "version": "1.1.0",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "nx": {
+    "name": "fiat-deposits-js"
+  }
+}