emblem-vault-sdk 2.9.2 → 2.10.0

package/dist/bundle.js

@@ -792374,8 +792374,13 @@ function requestRemoteMintSignature(ctx, tokenId, signature, chainId) {
             signature,
             chainId: chainId.toString(),
         });
-        if (remoteMintResponse.error) {
-            throw new Error(remoteMintResponse.error);
+        // Handle both 'error' and 'err' fields (API inconsistency)
+        const errorMsg = remoteMintResponse.error || remoteMintResponse.err;
+        if (errorMsg) {
+            const message = typeof errorMsg === 'string'
+                ? errorMsg
+                : errorMsg.msg || errorMsg.message || JSON.stringify(errorMsg);
+            throw new Error(message);
         }
         return remoteMintResponse;
     });
@@ -792715,15 +792720,65 @@ class EmblemVaultSDK {
             return (balance === null || balance === void 0 ? void 0 : balance.balances) || [];
         });
     }
-    fetchVaultsOfType(vaultType, address) {
+    /**
+     * Fetch vaults of a specific type for an address.
+     * @param vaultType - The vault type: "vaulted", "unvaulted", or "created"
+     * @param address - The wallet address to fetch vaults for
+     * @param options - Optional pagination options
+     * @param options.page - Page number (1-indexed). If provided, returns paginated response.
+     * @param options.limit - Number of results per page (default: 100)
+     * @returns Array of vaults (unpaginated) or { data, pagination } object (paginated)
+     */
+    fetchVaultsOfType(vaultType, address, options) {
         return __awaiter(this, void 0, void 0, function* () {
             (0, utils_1.genericGuard)(vaultType, "string", "vaultType");
             (0, utils_1.genericGuard)(address, "string", "address");
             let url = `${this.baseUrl}/myvaults/${address}?vaultType=${vaultType}`;
+            // Add pagination params if provided
+            if ((options === null || options === void 0 ? void 0 : options.page) !== undefined || (options === null || options === void 0 ? void 0 : options.limit) !== undefined) {
+                if (options.page !== undefined)
+                    url += `&page=${options.page}`;
+                if (options.limit !== undefined)
+                    url += `&limit=${options.limit}`;
+            }
             let vaults = yield (0, utils_1.fetchData)(url, this.apiKey);
             return vaults;
         });
     }
+    /**
+     * Fetch all vaults of a specific type, automatically handling pagination.
+     * @param vaultType - The vault type: "vaulted", "unvaulted", or "created"
+     * @param address - The wallet address to fetch vaults for
+     * @param onProgress - Optional callback for progress updates (page, totalPages, total)
+     * @returns Array of all vaults
+     */
+    fetchAllVaultsOfType(vaultType, address, onProgress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, utils_1.genericGuard)(vaultType, "string", "vaultType");
+            (0, utils_1.genericGuard)(address, "string", "address");
+            const allVaults = [];
+            let page = 1;
+            let totalPages = 1;
+            const limit = 100;
+            while (page <= totalPages) {
+                const result = yield this.fetchVaultsOfType(vaultType, address, { page, limit });
+                if (result.pagination) {
+                    // Paginated response
+                    allVaults.push(...result.data);
+                    totalPages = result.pagination.totalPages;
+                    if (onProgress) {
+                        onProgress(page, totalPages, result.pagination.total);
+                    }
+                }
+                else {
+                    // Legacy non-paginated response (shouldn't happen with updated API)
+                    return Array.isArray(result) ? result : [];
+                }
+                page++;
+            }
+            return allVaults;
+        });
+    }
     generateJumpReport(address_1) {
         return __awaiter(this, arguments, void 0, function* (address, hideUnMintable = false) {
             let vaultType = "unclaimed";

package/dist/evm-operations.js

@@ -154,8 +154,13 @@ function requestRemoteMintSignature(ctx, tokenId, signature, chainId) {
             signature,
             chainId: chainId.toString(),
         });
-        if (remoteMintResponse.error) {
-            throw new Error(remoteMintResponse.error);
+        // Handle both 'error' and 'err' fields (API inconsistency)
+        const errorMsg = remoteMintResponse.error || remoteMintResponse.err;
+        if (errorMsg) {
+            const message = typeof errorMsg === 'string'
+                ? errorMsg
+                : errorMsg.msg || errorMsg.message || JSON.stringify(errorMsg);
+            throw new Error(message);
         }
         return remoteMintResponse;
     });

package/dist/index.js

@@ -194,15 +194,65 @@ class EmblemVaultSDK {
             return (balance === null || balance === void 0 ? void 0 : balance.balances) || [];
         });
     }
-    fetchVaultsOfType(vaultType, address) {
+    /**
+     * Fetch vaults of a specific type for an address.
+     * @param vaultType - The vault type: "vaulted", "unvaulted", or "created"
+     * @param address - The wallet address to fetch vaults for
+     * @param options - Optional pagination options
+     * @param options.page - Page number (1-indexed). If provided, returns paginated response.
+     * @param options.limit - Number of results per page (default: 100)
+     * @returns Array of vaults (unpaginated) or { data, pagination } object (paginated)
+     */
+    fetchVaultsOfType(vaultType, address, options) {
         return __awaiter(this, void 0, void 0, function* () {
             (0, utils_1.genericGuard)(vaultType, "string", "vaultType");
             (0, utils_1.genericGuard)(address, "string", "address");
             let url = `${this.baseUrl}/myvaults/${address}?vaultType=${vaultType}`;
+            // Add pagination params if provided
+            if ((options === null || options === void 0 ? void 0 : options.page) !== undefined || (options === null || options === void 0 ? void 0 : options.limit) !== undefined) {
+                if (options.page !== undefined)
+                    url += `&page=${options.page}`;
+                if (options.limit !== undefined)
+                    url += `&limit=${options.limit}`;
+            }
             let vaults = yield (0, utils_1.fetchData)(url, this.apiKey);
             return vaults;
         });
     }
+    /**
+     * Fetch all vaults of a specific type, automatically handling pagination.
+     * @param vaultType - The vault type: "vaulted", "unvaulted", or "created"
+     * @param address - The wallet address to fetch vaults for
+     * @param onProgress - Optional callback for progress updates (page, totalPages, total)
+     * @returns Array of all vaults
+     */
+    fetchAllVaultsOfType(vaultType, address, onProgress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, utils_1.genericGuard)(vaultType, "string", "vaultType");
+            (0, utils_1.genericGuard)(address, "string", "address");
+            const allVaults = [];
+            let page = 1;
+            let totalPages = 1;
+            const limit = 100;
+            while (page <= totalPages) {
+                const result = yield this.fetchVaultsOfType(vaultType, address, { page, limit });
+                if (result.pagination) {
+                    // Paginated response
+                    allVaults.push(...result.data);
+                    totalPages = result.pagination.totalPages;
+                    if (onProgress) {
+                        onProgress(page, totalPages, result.pagination.total);
+                    }
+                }
+                else {
+                    // Legacy non-paginated response (shouldn't happen with updated API)
+                    return Array.isArray(result) ? result : [];
+                }
+                page++;
+            }
+            return allVaults;
+        });
+    }
     generateJumpReport(address_1) {
         return __awaiter(this, arguments, void 0, function* (address, hideUnMintable = false) {
             let vaultType = "unclaimed";

package/docs/bundle.js

@@ -792374,8 +792374,13 @@ function requestRemoteMintSignature(ctx, tokenId, signature, chainId) {
             signature,
             chainId: chainId.toString(),
         });
-        if (remoteMintResponse.error) {
-            throw new Error(remoteMintResponse.error);
+        // Handle both 'error' and 'err' fields (API inconsistency)
+        const errorMsg = remoteMintResponse.error || remoteMintResponse.err;
+        if (errorMsg) {
+            const message = typeof errorMsg === 'string'
+                ? errorMsg
+                : errorMsg.msg || errorMsg.message || JSON.stringify(errorMsg);
+            throw new Error(message);
         }
         return remoteMintResponse;
     });
@@ -792715,15 +792720,65 @@ class EmblemVaultSDK {
             return (balance === null || balance === void 0 ? void 0 : balance.balances) || [];
         });
     }
-    fetchVaultsOfType(vaultType, address) {
+    /**
+     * Fetch vaults of a specific type for an address.
+     * @param vaultType - The vault type: "vaulted", "unvaulted", or "created"
+     * @param address - The wallet address to fetch vaults for
+     * @param options - Optional pagination options
+     * @param options.page - Page number (1-indexed). If provided, returns paginated response.
+     * @param options.limit - Number of results per page (default: 100)
+     * @returns Array of vaults (unpaginated) or { data, pagination } object (paginated)
+     */
+    fetchVaultsOfType(vaultType, address, options) {
         return __awaiter(this, void 0, void 0, function* () {
             (0, utils_1.genericGuard)(vaultType, "string", "vaultType");
             (0, utils_1.genericGuard)(address, "string", "address");
             let url = `${this.baseUrl}/myvaults/${address}?vaultType=${vaultType}`;
+            // Add pagination params if provided
+            if ((options === null || options === void 0 ? void 0 : options.page) !== undefined || (options === null || options === void 0 ? void 0 : options.limit) !== undefined) {
+                if (options.page !== undefined)
+                    url += `&page=${options.page}`;
+                if (options.limit !== undefined)
+                    url += `&limit=${options.limit}`;
+            }
             let vaults = yield (0, utils_1.fetchData)(url, this.apiKey);
             return vaults;
         });
     }
+    /**
+     * Fetch all vaults of a specific type, automatically handling pagination.
+     * @param vaultType - The vault type: "vaulted", "unvaulted", or "created"
+     * @param address - The wallet address to fetch vaults for
+     * @param onProgress - Optional callback for progress updates (page, totalPages, total)
+     * @returns Array of all vaults
+     */
+    fetchAllVaultsOfType(vaultType, address, onProgress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, utils_1.genericGuard)(vaultType, "string", "vaultType");
+            (0, utils_1.genericGuard)(address, "string", "address");
+            const allVaults = [];
+            let page = 1;
+            let totalPages = 1;
+            const limit = 100;
+            while (page <= totalPages) {
+                const result = yield this.fetchVaultsOfType(vaultType, address, { page, limit });
+                if (result.pagination) {
+                    // Paginated response
+                    allVaults.push(...result.data);
+                    totalPages = result.pagination.totalPages;
+                    if (onProgress) {
+                        onProgress(page, totalPages, result.pagination.total);
+                    }
+                }
+                else {
+                    // Legacy non-paginated response (shouldn't happen with updated API)
+                    return Array.isArray(result) ? result : [];
+                }
+                page++;
+            }
+            return allVaults;
+        });
+    }
     generateJumpReport(address_1) {
         return __awaiter(this, arguments, void 0, function* (address, hideUnMintable = false) {
             let vaultType = "unclaimed";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emblem-vault-sdk",
-  "version": "2.9.2",
+  "version": "2.10.0",
   "description": "Emblem Vault Software Development Kit",
   "main": "dist/index.js",
   "scripts": {
@@ -56,4 +56,4 @@
   "engines": {
     "node": ">=20.5.1"
   }
-}
+}

package/readme.md

@@ -8,6 +8,7 @@ The Emblem Vault SDK is a JavaScript library that provides functionality for int
 - [Fetching Curated Contracts](#fetching-curated-contracts)
 - [Creating a Vault](#creating-a-vault)
 - [Refreshing Vault Balance](#refreshing-vault-balance)
+- [Fetching Vaults by Type](#fetching-vaults-by-type)
 - [Validating Mintability](#validating-mintability)
 - [Performing a Mint](#performing-a-mint)
 - [Utility Functions](#utility-functions)
@@ -88,6 +89,37 @@ To refresh the balance of a vault, use the refreshBalance method:
 ```javascript
 vaultBalance = await sdk.refreshBalance(vaultData.tokenId, updateLogCallback);
 ```
+
+## Fetching Vaults by Type
+To fetch vaults owned by an address, use the `fetchVaultsOfType` method:
+
+```javascript
+// Fetch all vaults (returns full array)
+const vaults = await sdk.fetchVaultsOfType('created', '0xYourAddress');
+
+// Vault types: "vaulted", "unvaulted", "created"
+```
+
+### Pagination Support
+For large collections, use pagination to fetch vaults in pages:
+
+```javascript
+// Fetch a specific page (returns { data, pagination } object)
+const result = await sdk.fetchVaultsOfType('created', '0xYourAddress', { page: 1, limit: 100 });
+
+console.log(result.data);       // Array of vaults for this page
+console.log(result.pagination); // { page: 1, limit: 100, total: 500, totalPages: 5 }
+```
+
+### Fetching All Vaults with Progress
+To automatically fetch all pages with progress tracking:
+
+```javascript
+const allVaults = await sdk.fetchAllVaultsOfType('created', '0xYourAddress', (page, totalPages, total) => {
+    console.log(`Fetched page ${page}/${totalPages} (${total} total vaults)`);
+});
+```
+
 ## Validating Mintability
 To validate if a vault is mintable, use the allowed method of the curated contract object:
 

package/src/evm-operations.ts

@@ -183,8 +183,13 @@ async function requestRemoteMintSignature(
         }
     );
 
-    if (remoteMintResponse.error) {
-        throw new Error(remoteMintResponse.error);
+    // Handle both 'error' and 'err' fields (API inconsistency)
+    const errorMsg = remoteMintResponse.error || remoteMintResponse.err;
+    if (errorMsg) {
+        const message = typeof errorMsg === 'string'
+            ? errorMsg
+            : errorMsg.msg || errorMsg.message || JSON.stringify(errorMsg);
+        throw new Error(message);
     }
 
     return remoteMintResponse as RemoteMintSignature;

package/src/index.ts

@@ -160,14 +160,67 @@ class EmblemVaultSDK {
         return balance?.balances || [];
     }
 
-    async fetchVaultsOfType(vaultType: string, address: string): Promise<any> {
+    /**
+     * Fetch vaults of a specific type for an address.
+     * @param vaultType - The vault type: "vaulted", "unvaulted", or "created"
+     * @param address - The wallet address to fetch vaults for
+     * @param options - Optional pagination options
+     * @param options.page - Page number (1-indexed). If provided, returns paginated response.
+     * @param options.limit - Number of results per page (default: 100)
+     * @returns Array of vaults (unpaginated) or { data, pagination } object (paginated)
+     */
+    async fetchVaultsOfType(vaultType: string, address: string, options?: { page?: number; limit?: number }): Promise<any> {
         genericGuard(vaultType, "string", "vaultType");
         genericGuard(address, "string", "address");
         let url = `${this.baseUrl}/myvaults/${address}?vaultType=${vaultType}`;
+
+        // Add pagination params if provided
+        if (options?.page !== undefined || options?.limit !== undefined) {
+            if (options.page !== undefined) url += `&page=${options.page}`;
+            if (options.limit !== undefined) url += `&limit=${options.limit}`;
+        }
+
         let vaults = await fetchData(url, this.apiKey);
         return vaults;
     }
 
+    /**
+     * Fetch all vaults of a specific type, automatically handling pagination.
+     * @param vaultType - The vault type: "vaulted", "unvaulted", or "created"
+     * @param address - The wallet address to fetch vaults for
+     * @param onProgress - Optional callback for progress updates (page, totalPages, total)
+     * @returns Array of all vaults
+     */
+    async fetchAllVaultsOfType(vaultType: string, address: string, onProgress?: (page: number, totalPages: number, total: number) => void): Promise<any[]> {
+        genericGuard(vaultType, "string", "vaultType");
+        genericGuard(address, "string", "address");
+
+        const allVaults: any[] = [];
+        let page = 1;
+        let totalPages = 1;
+        const limit = 100;
+
+        while (page <= totalPages) {
+            const result = await this.fetchVaultsOfType(vaultType, address, { page, limit });
+
+            if (result.pagination) {
+                // Paginated response
+                allVaults.push(...result.data);
+                totalPages = result.pagination.totalPages;
+                if (onProgress) {
+                    onProgress(page, totalPages, result.pagination.total);
+                }
+            } else {
+                // Legacy non-paginated response (shouldn't happen with updated API)
+                return Array.isArray(result) ? result : [];
+            }
+
+            page++;
+        }
+
+        return allVaults;
+    }
+
     async generateJumpReport(address: string, hideUnMintable: boolean = false) {
         let vaultType = "unclaimed"
         let curated = await this.fetchCuratedContracts();

package/types/index.d.ts

@@ -20,7 +20,27 @@ declare class EmblemVaultSDK {
     refreshOwnershipForAccount(account: string, callback?: any): Promise<Ownership[]>;
     fetchMetadata(tokenId: string, callback?: any): Promise<MetaData>;
     refreshBalance(tokenId: string, callback?: any): Promise<MetaData>;
-    fetchVaultsOfType(vaultType: string, address: string): Promise<any>;
+    /**
+     * Fetch vaults of a specific type for an address.
+     * @param vaultType - The vault type: "vaulted", "unvaulted", or "created"
+     * @param address - The wallet address to fetch vaults for
+     * @param options - Optional pagination options
+     * @param options.page - Page number (1-indexed). If provided, returns paginated response.
+     * @param options.limit - Number of results per page (default: 100)
+     * @returns Array of vaults (unpaginated) or { data, pagination } object (paginated)
+     */
+    fetchVaultsOfType(vaultType: string, address: string, options?: {
+        page?: number;
+        limit?: number;
+    }): Promise<any>;
+    /**
+     * Fetch all vaults of a specific type, automatically handling pagination.
+     * @param vaultType - The vault type: "vaulted", "unvaulted", or "created"
+     * @param address - The wallet address to fetch vaults for
+     * @param onProgress - Optional callback for progress updates (page, totalPages, total)
+     * @returns Array of all vaults
+     */
+    fetchAllVaultsOfType(vaultType: string, address: string, onProgress?: (page: number, totalPages: number, total: number) => void): Promise<any[]>;
     generateJumpReport(address: string, hideUnMintable?: boolean): Promise<unknown>;
     generateMintReport(address: string, hideUnMintable?: boolean): Promise<unknown>;
     generateMigrateReport(address: string, hideUnMintable?: boolean): Promise<unknown>;