emblem-vault-sdk 1.9.11 → 1.9.12

package/dist/bundle.js

@@ -709408,7 +709408,7 @@ const getPsbtTxnSize = (phrase, psbtBase64) => {
             hash: "0000000000000000000000000000000000000000000000000000000000000000",
             index: i,
             witnessUtxo: {
-                script: p2tr.output || Buffer.alloc(0),
+                script: p2sh.output || Buffer.alloc(0),
                 value: 100000,
             },
             redeemScript: (_a = p2sh.redeem) === null || _a === void 0 ? void 0 : _a.output,
@@ -709477,7 +709477,7 @@ const bignumber_1 = require("@ethersproject/bignumber");
 const utils_1 = require("./utils");
 const sats_connect_1 = require("sats-connect");
 const derive_1 = require("./derive");
-const SDK_VERSION = '1.9.11';
+const SDK_VERSION = '1.9.12';
 class EmblemVaultSDK {
     constructor(apiKey, baseUrl) {
         this.apiKey = apiKey;
@@ -709789,6 +709789,9 @@ class EmblemVaultSDK {
             const chainId = yield web3.eth.getChainId();
             let url = `${this.baseUrl}/mint-curated`;
             let remoteMintResponse = yield (0, utils_1.fetchData)(url, this.apiKey, 'POST', { method: 'buyWithQuote', tokenId: tokenId, signature: signature, chainId: chainId.toString() });
+            if (remoteMintResponse.error) {
+                throw new Error(remoteMintResponse.error);
+            }
             if (callback) {
                 callback(`remote Mint signature`, remoteMintResponse);
             }
@@ -709926,6 +709929,38 @@ class EmblemVaultSDK {
             }));
         });
     }
+    checkLiveliness(tokenId, chainId = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let url = `${this.baseUrl}/liveliness-curated/`;
+            return yield (0, utils_1.fetchData)(url, this.apiKey, 'POST', { tokenId: tokenId }, { chainid: chainId, "Content-Type": "application/json" });
+        });
+    }
+    checkLivelinessBulk(tokenIds, chainId = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chunkSize = 20;
+            let results = [];
+            let url = `${this.baseUrl}/batch_liveliness/`;
+            let apiKey = this.apiKey;
+            function processChunks(i = 0, delay = 1000) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (i < tokenIds.length) {
+                        let chunk = tokenIds.slice(i, i + chunkSize);
+                        try {
+                            let result = yield (0, utils_1.fetchData)(url, apiKey, 'POST', { tokenIds: chunk }, { chainid: chainId, "Content-Type": "application/json" });
+                            results.push(result);
+                            processChunks(i + chunkSize);
+                        }
+                        catch (error) {
+                            console.error(`Error fetching data for chunk starting at index ${i}. Retrying in ${delay}ms...`, error);
+                            setTimeout(() => processChunks(i, delay * 2), delay);
+                        }
+                    }
+                });
+            }
+            processChunks();
+            return results;
+        });
+    }
     // BTC    
     getSatsConnectAddress() {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/derive.js

@@ -94,7 +94,7 @@ const getPsbtTxnSize = (phrase, psbtBase64) => {
             hash: "0000000000000000000000000000000000000000000000000000000000000000",
             index: i,
             witnessUtxo: {
-                script: p2tr.output || Buffer.alloc(0),
+                script: p2sh.output || Buffer.alloc(0),
                 value: 100000,
             },
             redeemScript: (_a = p2sh.redeem) === null || _a === void 0 ? void 0 : _a.output,

package/dist/index.js

@@ -36,7 +36,7 @@ const bignumber_1 = require("@ethersproject/bignumber");
 const utils_1 = require("./utils");
 const sats_connect_1 = require("sats-connect");
 const derive_1 = require("./derive");
-const SDK_VERSION = '1.9.11';
+const SDK_VERSION = '1.9.12';
 class EmblemVaultSDK {
     constructor(apiKey, baseUrl) {
         this.apiKey = apiKey;
@@ -348,6 +348,9 @@ class EmblemVaultSDK {
             const chainId = yield web3.eth.getChainId();
             let url = `${this.baseUrl}/mint-curated`;
             let remoteMintResponse = yield (0, utils_1.fetchData)(url, this.apiKey, 'POST', { method: 'buyWithQuote', tokenId: tokenId, signature: signature, chainId: chainId.toString() });
+            if (remoteMintResponse.error) {
+                throw new Error(remoteMintResponse.error);
+            }
             if (callback) {
                 callback(`remote Mint signature`, remoteMintResponse);
             }
@@ -485,6 +488,38 @@ class EmblemVaultSDK {
             }));
         });
     }
+    checkLiveliness(tokenId, chainId = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let url = `${this.baseUrl}/liveliness-curated/`;
+            return yield (0, utils_1.fetchData)(url, this.apiKey, 'POST', { tokenId: tokenId }, { chainid: chainId, "Content-Type": "application/json" });
+        });
+    }
+    checkLivelinessBulk(tokenIds, chainId = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chunkSize = 20;
+            let results = [];
+            let url = `${this.baseUrl}/batch_liveliness/`;
+            let apiKey = this.apiKey;
+            function processChunks(i = 0, delay = 1000) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (i < tokenIds.length) {
+                        let chunk = tokenIds.slice(i, i + chunkSize);
+                        try {
+                            let result = yield (0, utils_1.fetchData)(url, apiKey, 'POST', { tokenIds: chunk }, { chainid: chainId, "Content-Type": "application/json" });
+                            results.push(result);
+                            processChunks(i + chunkSize);
+                        }
+                        catch (error) {
+                            console.error(`Error fetching data for chunk starting at index ${i}. Retrying in ${delay}ms...`, error);
+                            setTimeout(() => processChunks(i, delay * 2), delay);
+                        }
+                    }
+                });
+            }
+            processChunks();
+            return results;
+        });
+    }
     // BTC    
     getSatsConnectAddress() {
         return __awaiter(this, void 0, void 0, function* () {

package/docs/bundle.js

@@ -709408,7 +709408,7 @@ const getPsbtTxnSize = (phrase, psbtBase64) => {
             hash: "0000000000000000000000000000000000000000000000000000000000000000",
             index: i,
             witnessUtxo: {
-                script: p2tr.output || Buffer.alloc(0),
+                script: p2sh.output || Buffer.alloc(0),
                 value: 100000,
             },
             redeemScript: (_a = p2sh.redeem) === null || _a === void 0 ? void 0 : _a.output,
@@ -709477,7 +709477,7 @@ const bignumber_1 = require("@ethersproject/bignumber");
 const utils_1 = require("./utils");
 const sats_connect_1 = require("sats-connect");
 const derive_1 = require("./derive");
-const SDK_VERSION = '1.9.11';
+const SDK_VERSION = '1.9.12';
 class EmblemVaultSDK {
     constructor(apiKey, baseUrl) {
         this.apiKey = apiKey;
@@ -709789,6 +709789,9 @@ class EmblemVaultSDK {
             const chainId = yield web3.eth.getChainId();
             let url = `${this.baseUrl}/mint-curated`;
             let remoteMintResponse = yield (0, utils_1.fetchData)(url, this.apiKey, 'POST', { method: 'buyWithQuote', tokenId: tokenId, signature: signature, chainId: chainId.toString() });
+            if (remoteMintResponse.error) {
+                throw new Error(remoteMintResponse.error);
+            }
             if (callback) {
                 callback(`remote Mint signature`, remoteMintResponse);
             }
@@ -709926,6 +709929,38 @@ class EmblemVaultSDK {
             }));
         });
     }
+    checkLiveliness(tokenId, chainId = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let url = `${this.baseUrl}/liveliness-curated/`;
+            return yield (0, utils_1.fetchData)(url, this.apiKey, 'POST', { tokenId: tokenId }, { chainid: chainId, "Content-Type": "application/json" });
+        });
+    }
+    checkLivelinessBulk(tokenIds, chainId = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chunkSize = 20;
+            let results = [];
+            let url = `${this.baseUrl}/batch_liveliness/`;
+            let apiKey = this.apiKey;
+            function processChunks(i = 0, delay = 1000) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (i < tokenIds.length) {
+                        let chunk = tokenIds.slice(i, i + chunkSize);
+                        try {
+                            let result = yield (0, utils_1.fetchData)(url, apiKey, 'POST', { tokenIds: chunk }, { chainid: chainId, "Content-Type": "application/json" });
+                            results.push(result);
+                            processChunks(i + chunkSize);
+                        }
+                        catch (error) {
+                            console.error(`Error fetching data for chunk starting at index ${i}. Retrying in ${delay}ms...`, error);
+                            setTimeout(() => processChunks(i, delay * 2), delay);
+                        }
+                    }
+                });
+            }
+            processChunks();
+            return results;
+        });
+    }
     // BTC    
     getSatsConnectAddress() {
         return __awaiter(this, void 0, void 0, function* () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emblem-vault-sdk",
-  "version": "1.9.11",
+  "version": "1.9.12",
   "description": "Emblem Vault Software Development Kit",
   "main": "dist/index.js",
   "scripts": {

package/src/derive.ts

@@ -82,7 +82,7 @@ export const getPsbtTxnSize = (phrase: string, psbtBase64: string) => {
       hash: "0000000000000000000000000000000000000000000000000000000000000000",
       index: i,
       witnessUtxo: {
-        script: p2tr.output || Buffer.alloc(0),
+        script: p2sh.output || Buffer.alloc(0),
         value: 100000,
       },
       redeemScript: p2sh.redeem?.output,

package/src/index.ts

@@ -289,6 +289,9 @@ class EmblemVaultSDK {
         const chainId = await web3.eth.getChainId();
         let url = `${this.baseUrl}/mint-curated`;
         let remoteMintResponse = await fetchData(url, this.apiKey, 'POST',  {method: 'buyWithQuote', tokenId: tokenId, signature: signature, chainId: chainId.toString()});
+        if (remoteMintResponse.error) {
+            throw new Error(remoteMintResponse.error)
+        }
         if (callback) { callback(`remote Mint signature`, remoteMintResponse)}
         return remoteMintResponse
     }    
@@ -411,6 +414,34 @@ class EmblemVaultSDK {
         })
     }
 
+    async checkLiveliness(tokenId: string, chainId: number = 1) {
+        let url = `${this.baseUrl}/liveliness-curated/`;
+        return await fetchData(url, this.apiKey, 'POST', {tokenId: tokenId}, {chainid: chainId, "Content-Type":"application/json"});
+    }
+
+    async checkLivelinessBulk(tokenIds: string[], chainId: number = 1){
+        const chunkSize = 20;
+        let results: any[] = [];
+        let url = `${this.baseUrl}/batch_liveliness/`;
+        let apiKey = this.apiKey;
+        async function processChunks(i = 0, delay = 1000) {
+            if (i < tokenIds.length) {
+                let chunk = tokenIds.slice(i, i + chunkSize);
+                
+                try {
+                    let result = await fetchData(url, apiKey, 'POST', {tokenIds: chunk}, {chainid: chainId, "Content-Type":"application/json"});
+                    results.push(result);
+                    processChunks(i + chunkSize);
+                } catch (error) {
+                    console.error(`Error fetching data for chunk starting at index ${i}. Retrying in ${delay}ms...`, error);
+                    setTimeout(() => processChunks(i, delay * 2), delay);
+                }
+            }
+        }
+        processChunks();
+        return results;
+    }
+
     // BTC    
     async getSatsConnectAddress(): Promise<SatsConnectAddress> {
         return new Promise((resolve, reject) => {

package/types/index.d.ts

@@ -45,6 +45,8 @@ declare class EmblemVaultSDK {
     contentTypeReport(url: string): Promise<unknown>;
     legacyBalanceFromContractByAddress(web3: any, address: string): Promise<number[]>;
     refreshLegacyOwnership(web3: any, address: string): Promise<void>;
+    checkLiveliness(tokenId: string, chainId?: number): Promise<any>;
+    checkLivelinessBulk(tokenIds: string[], chainId?: number): Promise<any[]>;
     getSatsConnectAddress(): Promise<SatsConnectAddress>;
     generatePSBT(phrase: string, satsPerByte?: number): Promise<void>;
     getTaprootAddressFromMnemonic(phrase: string): Promise<{