npm - @zerohash-sdk/csp-crypto-withdrawals-js - Versions diffs - 1.1.0 - Mend

@zerohash-sdk/csp-crypto-withdrawals-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/csp-crypto-withdrawals-js
+A JavaScript SDK that enables frontend applications to seamlessly integrate with the Connect CSP Crypto Withdrawals product.
+Connect CSP Crypto Withdrawals provides a secure, customizable flow for withdrawing crypto assets directly within your application.
+## Installation
+### Via NPM (recommended)
+```bash
+npm install @zerohash-sdk/csp-crypto-withdrawals-js
+```
+```javascript
+import { CspCryptoWithdrawals } from '@zerohash-sdk/csp-crypto-withdrawals-js';
+```
+### Via CDN
+```html
+<script
+  type="module"
+  src="https://sdk.connect.xyz/csp-crypto-withdrawals-web/index.js"
+></script>
+```
+Or import directly in your JavaScript code:
+```javascript
+import { CspCryptoWithdrawals } from 'https://sdk.connect.xyz/csp-crypto-withdrawals-web/index.js';
+```
+## Getting Started
+### 1. Import the CspCryptoWithdrawals module
+```javascript
+import { CspCryptoWithdrawals } from '@zerohash-sdk/csp-crypto-withdrawals-js';
+```
+### 2. Initialize and render the widget
+```javascript
+const cspCryptoWithdrawals = new CspCryptoWithdrawals({
+  jwt: 'your-jwt-token',
+  env: 'prod',
+  theme: 'auto',
+  onCompleted: ({ withdrawalRequestId, assetSymbol, amount, networkFee, withdrawalFee }) => {
+    console.log('Withdrawal completed:', withdrawalRequestId, amount, 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 cspCryptoWithdrawals.render(document.getElementById('csp-crypto-withdrawals-container'));
+cspCryptoWithdrawals.destroy();
+```
+### 2.1 Using TypeScript (optional)
+```typescript
+import { CspCryptoWithdrawals, CspCryptoWithdrawalsConfig } from '@zerohash-sdk/csp-crypto-withdrawals-js';
+const config: CspCryptoWithdrawalsConfig = {
+  jwt: 'your-jwt-token',
+  env: 'cert',
+  onCompleted: ({ withdrawalRequestId, assetSymbol, amount, networkFee, withdrawalFee }) => {
+    console.log(withdrawalRequestId, amount, assetSymbol);
+  },
+};
+const cspCryptoWithdrawals = new CspCryptoWithdrawals(config);
+await cspCryptoWithdrawals.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` | `({ withdrawalRequestId, assetSymbol, amount, networkFee, withdrawalFee }) => void` | No       | -        | Callback when the withdrawal 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<CspCryptoWithdrawalsConfig>): void`
+#### `destroy(): void`
+#### `isRendered(): boolean`
+#### `getConfig(): CspCryptoWithdrawalsConfig`
+## 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,468 @@
+/**
+ * Zerohash CSP Crypto Withdrawals JavaScript SDK
+ *
+ * A programmatic JavaScript SDK for integrating the CSP Crypto Withdrawals widget
+ * into web applications without requiring HTML custom elements.
+ *
+ * @packageDocumentation
+ */
+/**
+ * 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;
+};
+/**
+ * CspCryptoWithdrawals SDK class for programmatic control of the Connect CSP Crypto Withdrawals widget.
+ *
+ * Renders the `zerohash-csp-crypto-withdrawals` web component, which handles the iframe
+ * and postMessage communication internally.
+ *
+ * @example
+ * ```javascript
+ * const cspCryptoWithdrawals = new CspCryptoWithdrawals({
+ *   jwt: 'your-jwt-token',
+ *   env: 'prod',
+ *   theme: 'auto',
+ *   onCompleted: (data) => console.log('Withdrawal complete', data),
+ *   onClose: () => console.log('Closed'),
+ *   onError: ({ errorCode, reason }) => console.error(errorCode, reason),
+ * });
+ *
+ * // Render to a container
+ * await cspCryptoWithdrawals.render(document.getElementById('csp-crypto-withdrawals-container'));
+ *
+ * // Update configuration
+ * cspCryptoWithdrawals.updateConfig({ jwt: 'new-token', theme: 'dark' });
+ *
+ * // Clean up
+ * cspCryptoWithdrawals.destroy();
+ * ```
+ */
+declare class CspCryptoWithdrawals extends BaseJsSdk<CspCryptoWithdrawalsConfig> {
+    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(container: HTMLElement): Promise<void>;
+    updateConfig(config: Partial<CspCryptoWithdrawalsConfig>): void;
+    getConfig(): Readonly<CspCryptoWithdrawalsConfig>;
+    isRendered(): boolean;
+    destroy(): void;
+}
+export { CspCryptoWithdrawals }
+export default CspCryptoWithdrawals;
+declare type CspCryptoWithdrawalsCallbacks = CommonCallbacks<CspCryptoWithdrawalsEvent> & {
+    /** Called when the withdrawal is successfully completed */
+    onCompleted?: (data: CspCryptoWithdrawalsCompletedData) => void;
+};
+declare type CspCryptoWithdrawalsCompletedData = {
+    /** ID of the withdrawal request */
+    withdrawalRequestId: string;
+    /** Symbol of the asset being withdrawn (e.g. 'BTC') */
+    assetSymbol: string;
+    /** Amount being withdrawn as a string */
+    amount: string;
+    /** Network fee as a string */
+    networkFee: string;
+    /** Withdrawal fee as a string */
+    withdrawalFee: string;
+};
+export declare interface CspCryptoWithdrawalsConfig extends BaseConfig<CspCryptoWithdrawalsEvent>, CspCryptoWithdrawalsCallbacks {
+}
+/**
+ * CSP Crypto Withdrawals event structure
+ */
+declare type CspCryptoWithdrawalsEvent = AppEvent<CspCryptoWithdrawalsEventType>;
+/**
+ * CSP Crypto Withdrawals event type literals
+ */
+declare type CspCryptoWithdrawalsEventType = string;
+/**
+ * Environment configuration for the SDK
+ */
+export declare type Environment = 'local' | 'dev' | 'cert' | 'prod' | 'sandbox' | 'production';
+/**
+ * Generic error codes for all Connect applications
+ */
+export 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;
+};
+/**
+ * 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 declare type ZerohashCspCryptoWithdrawalsElement = SdkElement<CspCryptoWithdrawalsConfig>;
+export { }

package/dist/index.js ADDED Viewed

@@ -0,0 +1,180 @@
+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 r = this.createWebComponent();
+      e.innerHTML = "", e.appendChild(r), this.state.container = e, this.state.element = r, this.state.initialized = !0;
+    } catch (r) {
+      throw console.error("Failed to render widget:", r), r;
+    }
+  }
+  /**
+   * 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 r = this.state.element;
+    Object.entries(e).forEach(([t, s]) => {
+      s && (this.config[t] = s, r[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, r) => {
+        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() : r(new Error(this.errorMessages.WEB_COMPONENT_NOT_DEFINED));
+          }, 0);
+        }, t.onerror = () => {
+          this.scriptLoadingPromise = void 0, r(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((r, t) => {
+        const s = setTimeout(() => {
+          t(new Error(`Timeout waiting for ${this.webComponentTag} to be defined`));
+        }, e);
+        customElements.whenDefined(this.webComponentTag).then(() => {
+          clearTimeout(s), r();
+        }).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(([r, t]) => {
+      t && (e[r] = t);
+    }), e;
+  }
+}
+var o;
+(function(i) {
+  i.NETWORK_ERROR = "network_error", i.AUTH_ERROR = "auth_error", i.NOT_FOUND_ERROR = "not_found_error", i.VALIDATION_ERROR = "validation_error", i.SERVER_ERROR = "server_error", i.CLIENT_ERROR = "client_error", i.UNKNOWN_ERROR = "unknown_error";
+})(o || (o = {}));
+class h extends c {
+  errorMessages = {
+    ALREADY_RENDERED: "CspCryptoWithdrawals widget is already rendered. Call destroy() before rendering again.",
+    NOT_RENDERED: "CspCryptoWithdrawals widget is not rendered. Call render() first.",
+    INVALID_CONTAINER: "Invalid container element provided.",
+    SCRIPT_LOAD_FAILED: "Failed to load the Connect CspCryptoWithdrawals script.",
+    WEB_COMPONENT_NOT_DEFINED: "Web component is not defined. Script may not be loaded."
+  };
+  scriptUrls = {
+    local: "http://localhost:5173/csp-crypto-withdrawals-web/index.js",
+    dev: "https://connect-sdk.dev.0hash.com/csp-crypto-withdrawals-web/index.js",
+    cert: "https://sdk.sandbox.connect.xyz/csp-crypto-withdrawals-web/index.js",
+    prod: "https://sdk.connect.xyz/csp-crypto-withdrawals-web/index.js",
+    sandbox: "https://sdk.sandbox.connect.xyz/csp-crypto-withdrawals-web/index.js",
+    production: "https://sdk.connect.xyz/csp-crypto-withdrawals-web/index.js"
+  };
+  webComponentTag = "zerohash-csp-crypto-withdrawals";
+  render(e) {
+    return super.render(e);
+  }
+  updateConfig(e) {
+    return super.updateConfig(e);
+  }
+  getConfig() {
+    return super.getConfig();
+  }
+  isRendered() {
+    return super.isRendered();
+  }
+  destroy() {
+    return super.destroy();
+  }
+}
+export {
+  h as CspCryptoWithdrawals,
+  o as ErrorCode,
+  h as default
+};

package/dist/index.umd.cjs ADDED Viewed

@@ -0,0 +1 @@

package/package.json ADDED Viewed

@@ -0,0 +1,25 @@
+{
+  "name": "@zerohash-sdk/csp-crypto-withdrawals-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": "csp-crypto-withdrawals-js"
+  }
+}