@pollar/core 0.7.0 → 0.7.1

package/dist/index.d.ts

@@ -390,6 +390,21 @@ type RampsTransactionResponse = paths['/ramps/transaction/{txId}']['get']['respo
 type RampTxStatus = RampsTransactionResponse['status'];
 type RampDirection = RampsTransactionResponse['direction'];
 type PaymentInstructions = RampsOnrampResponse['paymentInstructions'];
+type DistributionRule = paths['/distribution/rules']['get']['responses'][200]['content']['application/json']['content']['rules'][number];
+type RulePeriod = DistributionRule['period'];
+type DistributionClaimBody = NonNullable<paths['/distribution/claim']['post']['requestBody']>['content']['application/json'];
+type DistributionClaimContent = paths['/distribution/claim']['post']['responses'][200]['content']['application/json']['content'];
+type DistributionRulesState = {
+    step: 'idle';
+} | {
+    step: 'loading';
+} | {
+    step: 'loaded';
+    rules: DistributionRule[];
+} | {
+    step: 'error';
+    message: string;
+};
 type AdapterFn<TParams = unknown> = (params: TParams) => Promise<{
     unsignedTransaction: string;
 }>;
@@ -423,6 +438,13 @@ declare class PollarClient {
     private _profile;
     /** Last `DPoP-Nonce` we saw from a server response. Carried into the next proof. */
     private _dpopNonce;
+    /**
+     * Snapshot of each in-flight request's body, taken in `onRequest` before
+     * `fetch()` consumes the stream. Needed because `Request.clone()` throws
+     * once the body is disturbed, so the auto-retry path (DPoP nonce challenge
+     * / 401 refresh) must rebuild the request from scratch instead of cloning.
+     */
+    private _requestBodyCache;
     /** Singleton in-flight refresh — concurrent 401s coalesce into one /auth/refresh call. */
     private _refreshPromise;
     private _storageEventHandler;
@@ -544,6 +566,8 @@ declare class PollarClient {
         intervalMs?: number;
         timeoutMs?: number;
     }): Promise<RampTxStatus>;
+    listDistributionRules(): Promise<DistributionRule[]>;
+    claimDistributionRule(body: DistributionClaimBody): Promise<DistributionClaimContent>;
     private _setTxHistoryState;
     private _setWalletBalanceState;
     private _newController;
@@ -953,9 +977,18 @@ interface paths {
         trace?: never;
     };
     "/auth/logout": {
-        parameters: { query?: never; header?: never; path?: never; cookie?: never };
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
         get?: never;
         put?: never;
+        /**
+         * Revoke the current session (or all sessions)
+         * @description Server-side logout. Default behavior revokes the refresh-token family bound to the current access token. Pass `{"everywhere":true}` to revoke every active family for the authenticated user (logout from all devices).
+         */
         post: operations["postAuthLogout"];
         delete?: never;
         options?: never;
@@ -964,7 +997,16 @@ interface paths {
         trace?: never;
     };
     "/auth/sessions": {
-        parameters: { query?: never; header?: never; path?: never; cookie?: never };
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List active sessions for the authenticated user
+         * @description Returns one row per active refresh-token family with the metadata captured at issuance (user agent, hashed IP, optional device label). The session whose `current: true` flag matches the access token in use can be highlighted in the UI.
+         */
         get: operations["getAuthSessions"];
         put?: never;
         post?: never;
@@ -975,11 +1017,17 @@ interface paths {
         trace?: never;
     };
     "/auth/sessions/{familyId}": {
-        parameters: { query?: never; header?: never; path?: never; cookie?: never };
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
         get?: never;
         put?: never;
         post?: never;
-        delete: operations["deleteAuthSessionByFamilyId"];
+        /** Revoke a specific session (refresh-token family) */
+        delete: operations["deleteAuthSessionsByFamilyId"];
         options?: never;
         head?: never;
         patch?: never;
@@ -1265,6 +1313,46 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/distribution/rules": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List distribution rules
+         * @description Returns every distribution rule defined for the calling application, each decorated with a `claimable` flag and (when not claimable) a `reason` ErrorCode the SDK can map to a UI message (expired, already claimed in window, exhausted, etc.).
+         */
+        get: operations["getDistributionRules"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/distribution/claim": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Claim a distribution rule
+         * @description Executes a claim against the given rule for the authenticated sdk-user. The server runs the same claimability checks as GET /distribution/rules against fresh counts; only the txHash and amount are returned on success.
+         */
+        post: operations["postDistributionClaim"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 interface operations {
     getHealth: {
@@ -2084,6 +2172,159 @@ interface operations {
             };
         };
     };
+    postAuthLogout: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    everywhere?: boolean;
+                };
+            };
+        };
+        responses: {
+            /** @description Sessions revoked */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        code: "SDK_LOGOUT_SUCCESS";
+                        /** @constant */
+                        success: true;
+                        content: {
+                            revoked: number;
+                        };
+                    };
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getAuthSessions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Sessions list */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        code: "SDK_SESSIONS_LIST";
+                        /** @constant */
+                        success: true;
+                        content: {
+                            sessions: {
+                                familyId: string;
+                                createdAt: string;
+                                lastUsedAt: string | null;
+                                userAgent: string | null;
+                                ipHash: string | null;
+                                deviceLabel: string | null;
+                                current: boolean;
+                                expiresAt: string;
+                            }[];
+                        };
+                    };
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    deleteAuthSessionsByFamilyId: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                familyId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Session revoked */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        code: "SDK_SESSION_REVOKED";
+                        /** @constant */
+                        success: true;
+                        content: {
+                            revoked: number;
+                        };
+                    };
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        error: string;
+                    };
+                };
+            };
+            /** @description Not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
     getApplicationsConfig: {
         parameters: {
             query?: never;
@@ -3294,86 +3535,137 @@ interface operations {
             };
         };
     };
-    postAuthLogout: {
-        parameters: { query?: never; header?: never; path?: never; cookie?: never };
-        requestBody?: {
-            content: {
-                "application/json": {
-                    everywhere?: boolean;
-                };
-            };
+    getDistributionRules: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
+            /** @description List of distribution rules with claimability verdict per rule */
             200: {
-                headers: { [name: string]: unknown };
+                headers: {
+                    [name: string]: unknown;
+                };
                 content: {
                     "application/json": {
                         /** @constant */
-                        code: "SDK_LOGOUT_SUCCESS";
+                        code: "SDK_DISTRIBUTION_RULES_LIST";
                         /** @constant */
                         success: true;
                         content: {
-                            revoked: number;
+                            rules: {
+                                id: string;
+                                name: string;
+                                assetCode: string;
+                                amount: string;
+                                /** @enum {string} */
+                                period: "DAY" | "DAY_CALENDAR" | "WEEK" | "MONTH" | "MONTH_CALENDAR" | "LIFETIME";
+                                validFrom: string | null;
+                                validUntil: string | null;
+                                claimable: boolean;
+                                reason: string | null;
+                            }[];
                         };
                     };
                 };
             };
-        };
-    };
-    getAuthSessions: {
-        parameters: { query?: never; header?: never; path?: never; cookie?: never };
-        requestBody?: never;
-        responses: {
-            200: {
-                headers: { [name: string]: unknown };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
                 content: {
                     "application/json": {
                         /** @constant */
-                        code: "SDK_SESSIONS_LIST";
-                        /** @constant */
-                        success: true;
-                        content: {
-                            sessions: {
-                                familyId: string;
-                                createdAt: string;
-                                lastUsedAt: string | null;
-                                userAgent: string | null;
-                                ipHash: string | null;
-                                deviceLabel: string | null;
-                                current: boolean;
-                                expiresAt: string;
-                            }[];
-                        };
+                        success: false;
+                        error: string;
                     };
                 };
             };
         };
     };
-    deleteAuthSessionByFamilyId: {
+    postDistributionClaim: {
         parameters: {
             query?: never;
             header?: never;
-            path: { familyId: string };
+            path?: never;
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": {
+                    ruleId: string;
+                };
+            };
+        };
         responses: {
+            /** @description Claim succeeded — payment submitted to Stellar */
             200: {
-                headers: { [name: string]: unknown };
+                headers: {
+                    [name: string]: unknown;
+                };
                 content: {
                     "application/json": {
                         /** @constant */
-                        code: "SDK_SESSION_REVOKED";
+                        code: "SDK_DISTRIBUTION_CLAIM_OK";
                         /** @constant */
                         success: true;
                         content: {
-                            revoked: number;
+                            ruleId: string;
+                            assetCode: string;
+                            amount: string;
+                            txHash: string | null;
                         };
                     };
                 };
             };
+            /** @description Validation error */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        error: string;
+                    };
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        error: string;
+                    };
+                };
+            };
+            /** @description Rule not found, user has no wallet, or application has no distribution wallet */
             404: {
-                headers: { [name: string]: unknown };
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        error: string;
+                    };
+                };
+            };
+            /** @description Rule not claimable (disabled, expired, exhausted, rate-limited) */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
                 content: {
                     "application/json": {
                         /** @constant */
@@ -3468,4 +3760,18 @@ declare function pollRampTransaction(api: PollarApiClient, txId: string, { inter
     timeoutMs?: number;
 }): Promise<RampTxStatus>;
 
-export { AUTH_ERROR_CODES, type AdapterFn, AlbedoAdapter, type AuthErrorCode, type AuthState, type BuildProofArgs, type ConnectWalletResponse, FreighterAdapter, type KeyManager, type KycFlow, type KycLevel, type KycProvider, type KycStartBody, type KycStartResponse, type KycStatus, type LocalStorageAdapterOptions, type NetworkState, OnStorageDegrade, type PaymentInstructions, type PollarAdapter, type PollarAdapters, type PollarApiClient, type PollarApplicationConfigContent, type PollarApplicationConfigResponse, PollarClient, type PollarClientConfig, PollarFlowError, type PollarLoginOptions, type PollarPersistedSession, type PollarUserProfile, type PublicEcJwk, type RampDirection, type RampQuote, type RampTxStatus, type RampsOfframpBody, type RampsOfframpResponse, type RampsOnrampBody, type RampsOnrampResponse, type RampsQuoteQuery, type RampsQuoteResponse, type RampsTransactionResponse, type SessionInfo, type SignAuthEntryOptions, type SignAuthEntryResponse, type SignTransactionOptions, type SignTransactionResponse, type StellarBalance, StellarClient, type StellarClientConfig, type StellarNetwork, Storage, type TransactionState, type TxBuildBody, type TxBuildContent, type TxBuildResponse, type TxHistoryContent, type TxHistoryParams, type TxHistoryRecord, type TxHistoryState, type TxSignAndSendBody, type TxSignSendResponse, type WalletAdapter, type WalletAdapterResolver, type WalletBalanceContent, type WalletBalanceRecord, type WalletBalanceState, type WalletId, WalletType, WebCryptoKeyManager, buildProof, canonicalEcJwk, computeJwkThumbprint, createLocalStorageAdapter, createMemoryAdapter, createOffRamp, createOnRamp, defaultKeyManager, defaultStorage, getKycProviders, getKycStatus, getRampTransaction, getRampsQuote, isValidSession, normalizeHtu, pollKycStatus, pollRampTransaction, type paths as pollarPaths, resolveKyc, startKyc };
+/**
+ * GET /distribution/rules
+ * Returns the distribution rules visible to the calling sdk-user, each
+ * decorated with `claimable` and (when not claimable) a `reason` ErrorCode
+ * the UI maps to a friendly message.
+ */
+declare function listDistributionRules(api: PollarApiClient): Promise<DistributionRule[]>;
+/**
+ * POST /distribution/claim
+ * Claims the given rule for the authenticated sdk-user. Returns the tx hash
+ * once the payment is submitted to Stellar.
+ */
+declare function claimDistributionRule(api: PollarApiClient, body: DistributionClaimBody): Promise<DistributionClaimContent>;
+
+export { AUTH_ERROR_CODES, type AdapterFn, AlbedoAdapter, type AuthErrorCode, type AuthState, type BuildProofArgs, type ConnectWalletResponse, type DistributionClaimBody, type DistributionClaimContent, type DistributionRule, type DistributionRulesState, FreighterAdapter, type KeyManager, type KycFlow, type KycLevel, type KycProvider, type KycStartBody, type KycStartResponse, type KycStatus, type LocalStorageAdapterOptions, type NetworkState, OnStorageDegrade, type PaymentInstructions, type PollarAdapter, type PollarAdapters, type PollarApiClient, type PollarApplicationConfigContent, type PollarApplicationConfigResponse, PollarClient, type PollarClientConfig, PollarFlowError, type PollarLoginOptions, type PollarPersistedSession, type PollarUserProfile, type PublicEcJwk, type RampDirection, type RampQuote, type RampTxStatus, type RampsOfframpBody, type RampsOfframpResponse, type RampsOnrampBody, type RampsOnrampResponse, type RampsQuoteQuery, type RampsQuoteResponse, type RampsTransactionResponse, type RulePeriod, type SessionInfo, type SignAuthEntryOptions, type SignAuthEntryResponse, type SignTransactionOptions, type SignTransactionResponse, type StellarBalance, StellarClient, type StellarClientConfig, type StellarNetwork, Storage, type TransactionState, type TxBuildBody, type TxBuildContent, type TxBuildResponse, type TxHistoryContent, type TxHistoryParams, type TxHistoryRecord, type TxHistoryState, type TxSignAndSendBody, type TxSignSendResponse, type WalletAdapter, type WalletAdapterResolver, type WalletBalanceContent, type WalletBalanceRecord, type WalletBalanceState, type WalletId, WalletType, WebCryptoKeyManager, buildProof, canonicalEcJwk, claimDistributionRule, computeJwkThumbprint, createLocalStorageAdapter, createMemoryAdapter, createOffRamp, createOnRamp, defaultKeyManager, defaultStorage, getKycProviders, getKycStatus, getRampTransaction, getRampsQuote, isValidSession, listDistributionRules, normalizeHtu, pollKycStatus, pollRampTransaction, type paths as pollarPaths, resolveKyc, startKyc };

package/dist/index.js

@@ -442,7 +442,7 @@ function createClient(clientOptions) {
     const {
       baseUrl: localBaseUrl,
       fetch: fetch2 = baseFetch,
-      Request = CustomRequest,
+      Request: Request2 = CustomRequest,
       headers,
       params = {},
       parseAs = "json",
@@ -494,7 +494,7 @@ function createClient(clientOptions) {
     };
     let id;
     let options;
-    let request = new Request(
+    let request = new Request2(
       createFinalURL(schemaPath, { baseUrl: finalBaseUrl, params, querySerializer, pathSerializer }),
       requestInit
     );
@@ -524,7 +524,7 @@ function createClient(clientOptions) {
             id
           });
           if (result) {
-            if (result instanceof Request) {
+            if (result instanceof Request2) {
               request = result;
             } else if (result instanceof Response) {
               response = result;
@@ -896,6 +896,22 @@ function createApiClient(baseUrl) {
   return createClient({ baseUrl });
 }
 
+// src/api/endpoints/distribution.ts
+async function listDistributionRules(api) {
+  const { data, error } = await api.GET("/distribution/rules");
+  if (!data?.content || error) {
+    throw new Error(error?.error ?? "Failed to list distribution rules");
+  }
+  return data.content.rules;
+}
+async function claimDistributionRule(api, body) {
+  const { data, error } = await api.POST("/distribution/claim", { body });
+  if (!data?.content || error) {
+    throw new Error(error?.error ?? "Failed to claim distribution rule");
+  }
+  return data.content;
+}
+
 // src/api/endpoints/kyc.ts
 async function getKycStatus(api, providerId) {
   const { data, error } = await api.GET("/kyc/status", {
@@ -1742,7 +1758,6 @@ async function loginWallet(type, deps) {
 
 // src/client/client.ts
 var isBrowser = typeof window !== "undefined" && typeof localStorage !== "undefined";
-var RETRIED_HEADER = "X-Pollar-Retried";
 function warnServerSide(method) {
   console.warn(
     `[PollarClient] ${method}() called server-side \u2014 browser APIs unavailable. Use PollarClient only in Client Components.`
@@ -1760,6 +1775,13 @@ var PollarClient = class {
     this._profile = null;
     /** Last `DPoP-Nonce` we saw from a server response. Carried into the next proof. */
     this._dpopNonce = null;
+    /**
+     * Snapshot of each in-flight request's body, taken in `onRequest` before
+     * `fetch()` consumes the stream. Needed because `Request.clone()` throws
+     * once the body is disturbed, so the auto-retry path (DPoP nonce challenge
+     * / 401 refresh) must rebuild the request from scratch instead of cloning.
+     */
+    this._requestBodyCache = /* @__PURE__ */ new WeakMap();
     /** Singleton in-flight refresh — concurrent 401s coalesce into one /auth/refresh call. */
     this._refreshPromise = null;
     this._storageEventHandler = null;
@@ -1844,6 +1866,13 @@ var PollarClient = class {
       onRequest: async ({ request }) => {
         request.headers.set("x-pollar-api-key", self.apiKey);
         await self._initialized;
+        if (request.body !== null) {
+          try {
+            self._requestBodyCache.set(request, await request.clone().arrayBuffer());
+          } catch (err) {
+            console.warn("[PollarClient] Could not snapshot request body for retry", err);
+          }
+        }
         const isRefresh = request.url.includes("/auth/refresh");
         if (!isRefresh && self._refreshPromise) await self._refreshPromise;
         if (isRefresh) {
@@ -1866,7 +1895,6 @@ var PollarClient = class {
         const newNonce = response.headers.get("DPoP-Nonce");
         if (newNonce) self._dpopNonce = newNonce;
         if (response.status !== 401) return response;
-        if (request.headers.get(RETRIED_HEADER)) return response;
         if (request.url.includes("/auth/refresh")) return response;
         const wwwAuth = response.headers.get("WWW-Authenticate") ?? "";
         const isNonceChallenge = wwwAuth.includes("use_dpop_nonce");
@@ -1899,19 +1927,29 @@ var PollarClient = class {
     }
   }
   async _retryRequest(originalRequest) {
-    const clone = originalRequest.clone();
-    clone.headers.set(RETRIED_HEADER, "1");
+    const headers = new Headers(originalRequest.headers);
     const accessToken = this._session?.token?.accessToken;
     if (accessToken) {
-      const proof = await this._buildProofForRequest(clone, accessToken);
+      const proof = await this._buildProofForRequest(originalRequest, accessToken);
       if (proof) {
-        clone.headers.set("Authorization", `DPoP ${accessToken}`);
-        clone.headers.set("DPoP", proof);
+        headers.set("Authorization", `DPoP ${accessToken}`);
+        headers.set("DPoP", proof);
       } else {
-        clone.headers.set("Authorization", `Bearer ${accessToken}`);
+        headers.set("Authorization", `Bearer ${accessToken}`);
       }
     }
-    return fetch(clone);
+    const cachedBody = this._requestBodyCache.get(originalRequest);
+    const retried = new Request(originalRequest.url, {
+      method: originalRequest.method,
+      headers,
+      body: cachedBody ?? null,
+      credentials: originalRequest.credentials,
+      mode: originalRequest.mode,
+      redirect: originalRequest.redirect,
+      referrer: originalRequest.referrer,
+      integrity: originalRequest.integrity
+    });
+    return fetch(retried);
   }
   // ─── Refresh (race-safe singleton) ───────────────────────────────────────
   /**
@@ -2236,7 +2274,8 @@ var PollarClient = class {
         const details = error?.details;
         this._setTransactionState({ step: "error", ...details && { details } });
       }
-    } catch {
+    } catch (err) {
+      console.error("[PollarClient] buildTx failed", err);
       this._setTransactionState({ step: "error" });
     }
   }
@@ -2324,6 +2363,13 @@ var PollarClient = class {
   pollRampTransaction(txId, opts) {
     return pollRampTransaction(this._api, txId, opts);
   }
+  // ─── Distribution ─────────────────────────────────────────────────────────
+  listDistributionRules() {
+    return listDistributionRules(this._api);
+  }
+  claimDistributionRule(body) {
+    return claimDistributionRule(this._api, body);
+  }
   _setTxHistoryState(next) {
     this._txHistoryState = next;
     for (const cb of this._txHistoryStateListeners) cb(next);
@@ -2472,6 +2518,7 @@ exports.WalletType = WalletType;
 exports.WebCryptoKeyManager = WebCryptoKeyManager;
 exports.buildProof = buildProof;
 exports.canonicalEcJwk = canonicalEcJwk;
+exports.claimDistributionRule = claimDistributionRule;
 exports.computeJwkThumbprint = computeJwkThumbprint;
 exports.createLocalStorageAdapter = createLocalStorageAdapter;
 exports.createMemoryAdapter = createMemoryAdapter;
@@ -2484,6 +2531,7 @@ exports.getKycStatus = getKycStatus;
 exports.getRampTransaction = getRampTransaction;
 exports.getRampsQuote = getRampsQuote;
 exports.isValidSession = isValidSession;
+exports.listDistributionRules = listDistributionRules;
 exports.normalizeHtu = normalizeHtu;
 exports.pollKycStatus = pollKycStatus;
 exports.pollRampTransaction = pollRampTransaction;