emblem-vault-sdk 2.9.1 → 2.10.0

package/dist/constants.js

@@ -0,0 +1,35 @@
+"use strict";
+// ============================================================================
+// Supported Chains
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TORUS_SIGNER_API = exports.EMBLEM_API_2 = exports.EMBLEM_API_V2 = exports.ZERO_ADDRESS = exports.UNVAULTING_DIAMOND_ADDRESS = exports.HANDLER_CONTRACT_ADDRESS = exports.SUPPORTED_CHAINS = exports.SOLANA_CHAIN_IDENTIFIER = exports.POLYGON_MAINNET_CHAIN_ID = exports.ETHEREUM_MAINNET_CHAIN_ID = void 0;
+exports.ETHEREUM_MAINNET_CHAIN_ID = 1;
+exports.POLYGON_MAINNET_CHAIN_ID = 137;
+exports.SOLANA_CHAIN_IDENTIFIER = 'solana';
+exports.SUPPORTED_CHAINS = {
+    [exports.ETHEREUM_MAINNET_CHAIN_ID]: {
+        type: 'evm',
+        name: 'Ethereum Mainnet',
+        handlerContract: '0x23859b51117dbFBcdEf5b757028B18d7759a4460',
+        unvaultingContract: '0x214C964bBd3640971E111d3a994CbB89b296a9ad',
+    },
+    [exports.POLYGON_MAINNET_CHAIN_ID]: {
+        type: 'evm',
+        name: 'Polygon Mainnet',
+        handlerContract: '0x23859b51117dbFBcdEf5b757028B18d7759a4460',
+        unvaultingContract: '0x214C964bBd3640971E111d3a994CbB89b296a9ad',
+    },
+};
+// ============================================================================
+// Contract Addresses (default to Ethereum mainnet)
+// ============================================================================
+exports.HANDLER_CONTRACT_ADDRESS = '0x23859b51117dbFBcdEf5b757028B18d7759a4460';
+exports.UNVAULTING_DIAMOND_ADDRESS = '0x214C964bBd3640971E111d3a994CbB89b296a9ad';
+exports.ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+// ============================================================================
+// API Endpoints
+// ============================================================================
+exports.EMBLEM_API_V2 = 'https://v2.emblemvault.io';
+exports.EMBLEM_API_2 = 'https://api2.emblemvault.io';
+exports.TORUS_SIGNER_API = 'https://tor-us-signer-coval.vercel.app';

package/dist/evm-operations.js

@@ -0,0 +1,303 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performMintEvm = performMintEvm;
+exports.performClaimEvm = performClaimEvm;
+exports.deleteVaultEvm = deleteVaultEvm;
+const constants_1 = require("./constants");
+const signing_messages_1 = require("./signing-messages");
+const vault_utils_1 = require("./vault-utils");
+const utils_1 = require("./utils");
+const EVM_RPC_URLS = {
+    1: 'https://eth.llamarpc.com',
+    137: 'https://polygon-rpc.com',
+};
+function getEvmRpcUrl(chainId) {
+    return EVM_RPC_URLS[chainId] || EVM_RPC_URLS[1];
+}
+function performMintEvm(ctx, client, tokenId, chainId, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        callback === null || callback === void 0 ? void 0 : callback('Initializing EVM signer...');
+        const { ethers } = yield Promise.resolve().then(() => __importStar(require('ethers')));
+        const provider = new ethers.providers.JsonRpcProvider(getEvmRpcUrl(chainId));
+        const wallet = yield client.toEthersWallet(provider);
+        (_a = wallet.setChainId) === null || _a === void 0 ? void 0 : _a.call(wallet, chainId);
+        callback === null || callback === void 0 ? void 0 : callback('Signing mint request...');
+        const mintMessage = (0, signing_messages_1.buildMintMessage)(tokenId);
+        const mintRequestSig = yield wallet.signMessage(mintMessage);
+        callback === null || callback === void 0 ? void 0 : callback('Getting remote mint signature...');
+        const remoteMintSig = yield requestRemoteMintSignature(ctx, tokenId, mintRequestSig, chainId);
+        callback === null || callback === void 0 ? void 0 : callback('Submitting mint transaction...');
+        const txHash = yield submitMintTransaction(wallet, remoteMintSig, chainId, callback);
+        callback === null || callback === void 0 ? void 0 : callback('Mint complete!', { txHash });
+        return { txHash, tokenId, chainId };
+    });
+}
+function performClaimEvm(ctx, client, tokenId, chainId, metadata, claimIdentifier, vaultIsV2, needsOnChainUnvault, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        callback === null || callback === void 0 ? void 0 : callback('Initializing EVM signer...');
+        const { ethers } = yield Promise.resolve().then(() => __importStar(require('ethers')));
+        const provider = new ethers.providers.JsonRpcProvider(getEvmRpcUrl(chainId));
+        const wallet = yield client.toEthersWallet(provider);
+        (_a = wallet.setChainId) === null || _a === void 0 ? void 0 : _a.call(wallet, chainId);
+        // Determine if vault needs on-chain claim/unvault before getting keys
+        // For minted vaults (live=true, status=unclaimed), we must claim on-chain first
+        const isMinted = metadata.live === true || metadata.status === 'unclaimed';
+        const isAlreadyClaimed = metadata.status === 'claimed' || Boolean(metadata.claimedBy);
+        if (isMinted && !isAlreadyClaimed) {
+            if (needsOnChainUnvault) {
+                // V2 vault: use unvaultWithSignedPrice
+                yield performOnChainUnvault(ctx, wallet, tokenId, claimIdentifier, metadata.collectionAddress, chainId, callback);
+            }
+            else {
+                // Non-V2 vault: use handler's claim function
+                const targetContractAddress = ((_b = metadata.targetContract) === null || _b === void 0 ? void 0 : _b[chainId]) || metadata.collectionAddress;
+                if (targetContractAddress) {
+                    callback === null || callback === void 0 ? void 0 : callback('Performing on-chain claim...');
+                    yield performLegacyClaim(wallet, targetContractAddress, claimIdentifier, chainId, callback);
+                }
+            }
+        }
+        callback === null || callback === void 0 ? void 0 : callback('Signing claim message...');
+        const claimMessage = (0, signing_messages_1.buildClaimMessage)(claimIdentifier, vaultIsV2);
+        const signature = yield wallet.signMessage(claimMessage);
+        callback === null || callback === void 0 ? void 0 : callback('Requesting claim token...');
+        const jwt = yield requestClaimToken(tokenId, signature, chainId);
+        callback === null || callback === void 0 ? void 0 : callback('Requesting remote key...');
+        const decryptionKeys = yield ctx.requestRemoteKey(tokenId, jwt, callback);
+        if (!decryptionKeys) {
+            throw new Error('Failed to get decryption key');
+        }
+        callback === null || callback === void 0 ? void 0 : callback('Decrypting vault keys...');
+        return yield ctx.decryptVaultKeys(tokenId, decryptionKeys, callback);
+    });
+}
+function deleteVaultEvm(client, tokenId, chainId, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        callback === null || callback === void 0 ? void 0 : callback('Initializing EVM signer...');
+        const wallet = yield client.toEthersWallet(null);
+        (_a = wallet.setChainId) === null || _a === void 0 ? void 0 : _a.call(wallet, chainId);
+        callback === null || callback === void 0 ? void 0 : callback('Signing delete message...');
+        const deleteMessage = (0, signing_messages_1.buildDeleteMessage)(tokenId);
+        const signature = yield wallet.signMessage(deleteMessage);
+        callback === null || callback === void 0 ? void 0 : callback('Deleting vault...');
+        const response = yield fetch(`${constants_1.EMBLEM_API_2}/v2/delete`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                service: 'evmetadata',
+            },
+            body: JSON.stringify({
+                tokenId,
+                signature,
+                chainId: chainId.toString(),
+            }),
+        });
+        if (!response.ok) {
+            const errorData = yield response.json().catch(() => ({}));
+            throw new Error(errorData.message || 'Failed to delete vault');
+        }
+        callback === null || callback === void 0 ? void 0 : callback('Vault deleted successfully');
+        return true;
+    });
+}
+function requestRemoteMintSignature(ctx, tokenId, signature, chainId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const url = `${ctx.baseUrl}/mint-curated`;
+        const remoteMintResponse = yield (0, utils_1.fetchData)(url, ctx.apiKey, 'POST', {
+            method: 'buyWithSignedPrice',
+            tokenId,
+            signature,
+            chainId: chainId.toString(),
+        });
+        // 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;
+    });
+}
+function submitMintTransaction(wallet, remoteMintSig, chainId, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { ethers } = yield Promise.resolve().then(() => __importStar(require('ethers')));
+        const handlerAddress = (0, vault_utils_1.getHandlerContractAddress)(chainId);
+        const priceBigInt = (0, utils_1.parseBigIntValue)(remoteMintSig._price);
+        const iface = new ethers.utils.Interface([
+            'function buyWithSignedPrice(address _nftAddress, address _payment, uint256 _price, address _to, uint256 _tokenId, uint256 _nonce, bytes _signature, bytes serialNumber, uint256 _amount) payable'
+        ]);
+        const data = iface.encodeFunctionData('buyWithSignedPrice', [
+            remoteMintSig._nftAddress,
+            constants_1.ZERO_ADDRESS,
+            priceBigInt,
+            remoteMintSig._to,
+            (0, utils_1.parseBigIntValue)(remoteMintSig._tokenId),
+            (0, utils_1.parseBigIntValue)(remoteMintSig._nonce),
+            remoteMintSig._signature,
+            remoteMintSig.serialNumber,
+            BigInt(1),
+        ]);
+        const tx = yield wallet.sendTransaction({
+            to: handlerAddress,
+            data,
+            value: priceBigInt,
+        });
+        callback === null || callback === void 0 ? void 0 : callback('Waiting for confirmation...', { txHash: tx.hash });
+        yield tx.wait();
+        return tx.hash;
+    });
+}
+function performOnChainUnvault(ctx, wallet, tokenId, claimIdentifier, nftAddress, chainId, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        callback === null || callback === void 0 ? void 0 : callback('Signing unvault request...');
+        // Sign with tokenId to match server expectation (server verifies "Unvault: " + req.body.tokenId)
+        const unvaultMessage = (0, signing_messages_1.buildUnvaultMessage)(tokenId);
+        const unvaultSignature = yield wallet.signMessage(unvaultMessage);
+        callback === null || callback === void 0 ? void 0 : callback('Requesting remote unvault signature...');
+        const remoteUnvaultSig = yield requestRemoteUnvaultSignature(ctx, tokenId, unvaultSignature, chainId);
+        callback === null || callback === void 0 ? void 0 : callback('Submitting on-chain unvault transaction...');
+        yield submitUnvaultTransaction(wallet, remoteUnvaultSig, nftAddress, chainId, callback);
+        callback === null || callback === void 0 ? void 0 : callback('On-chain unvault complete, retrieving keys...');
+    });
+}
+/**
+ * Perform legacy claim by calling the handler contract's claim function
+ * This is for non-V2 vaults that don't use signed price unvaulting
+ */
+function performLegacyClaim(wallet, targetContractAddress, tokenId, chainId, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { ethers } = yield Promise.resolve().then(() => __importStar(require('ethers')));
+        // Handler contract ABI for claim function
+        const HANDLER_CLAIM_ABI = [
+            'function claim(address _nftAddress, uint256 _tokenId) external'
+        ];
+        const handlerAddress = (0, vault_utils_1.getHandlerContractAddress)(chainId);
+        const iface = new ethers.utils.Interface(HANDLER_CLAIM_ABI);
+        const data = iface.encodeFunctionData('claim', [
+            targetContractAddress,
+            BigInt(tokenId),
+        ]);
+        callback === null || callback === void 0 ? void 0 : callback('Submitting claim transaction...');
+        const tx = yield wallet.sendTransaction({
+            to: handlerAddress,
+            data,
+        });
+        callback === null || callback === void 0 ? void 0 : callback('Waiting for claim confirmation...', { txHash: tx.hash });
+        yield tx.wait();
+        callback === null || callback === void 0 ? void 0 : callback('On-chain claim complete!');
+    });
+}
+function requestRemoteUnvaultSignature(ctx, tokenId, signature, chainId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch(`${ctx.baseUrl}/unvault-curated`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                method: 'unvaultWithSignedPrice',
+                tokenId,
+                signature,
+                chainId: chainId.toString(),
+            }),
+        });
+        const remoteUnvaultSig = yield response.json();
+        if (!(remoteUnvaultSig === null || remoteUnvaultSig === void 0 ? void 0 : remoteUnvaultSig.success)) {
+            throw new Error((remoteUnvaultSig === null || remoteUnvaultSig === void 0 ? void 0 : remoteUnvaultSig.msg) || (remoteUnvaultSig === null || remoteUnvaultSig === void 0 ? void 0 : remoteUnvaultSig.err) || 'Failed to get remote unvault signature');
+        }
+        return remoteUnvaultSig;
+    });
+}
+function submitUnvaultTransaction(wallet, remoteUnvaultSig, nftAddress, chainId, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { ethers } = yield Promise.resolve().then(() => __importStar(require('ethers')));
+        const unvaultingAddress = (0, vault_utils_1.getUnvaultingContractAddress)(chainId);
+        const nftAddressToUse = nftAddress || remoteUnvaultSig._nftAddress;
+        const tokenId = (0, utils_1.parseBigIntValue)(remoteUnvaultSig._tokenId);
+        const nonce = (0, utils_1.parseBigIntValue)(remoteUnvaultSig._nonce);
+        const price = (0, utils_1.parseBigIntValue)(remoteUnvaultSig._price);
+        const timestamp = (0, utils_1.parseBigIntValue)(remoteUnvaultSig._timestamp);
+        const iface = new ethers.utils.Interface([
+            'function unvaultWithSignedPrice(address _nftAddress, uint256 _tokenId, uint256 _nonce, address _payment, uint256 _price, bytes _signature, uint256 _timestamp) payable'
+        ]);
+        const data = iface.encodeFunctionData('unvaultWithSignedPrice', [
+            nftAddressToUse,
+            tokenId,
+            nonce,
+            constants_1.ZERO_ADDRESS,
+            price,
+            remoteUnvaultSig._signature,
+            timestamp,
+        ]);
+        const tx = yield wallet.sendTransaction({
+            to: unvaultingAddress,
+            data,
+            value: price,
+        });
+        callback === null || callback === void 0 ? void 0 : callback('Waiting for unvault confirmation...', { txHash: tx.hash });
+        yield tx.wait();
+        return tx.hash;
+    });
+}
+function requestClaimToken(tokenId, signature, chainId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch(`${constants_1.TORUS_SIGNER_API}/sign`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                chainid: chainId.toString(),
+            },
+            body: JSON.stringify({ signature, tokenId }),
+        });
+        const jwt = yield response.json();
+        if (!jwt || jwt.success === false) {
+            throw new Error((jwt === null || jwt === void 0 ? void 0 : jwt.debug) ? `Claim failed: ${JSON.stringify(jwt.debug)}` : 'Failed to get claim token');
+        }
+        return jwt;
+    });
+}

package/dist/index.js

@@ -45,7 +45,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const bignumber_1 = require("@ethersproject/bignumber");
 const utils_1 = require("./utils");
 const derive_1 = require("./derive");
-const SDK_VERSION = '2.9.1';
+const constants_1 = require("./constants");
+const vault_utils_1 = require("./vault-utils");
+const evm_operations_1 = require("./evm-operations");
+const SDK_VERSION = '2.9.2';
 class EmblemVaultSDK {
     constructor(apiKey, baseUrl, v3Url, sigUrl) {
         this.apiKey = apiKey;
@@ -107,7 +110,7 @@ class EmblemVaultSDK {
                         item[key] = template[key];
                 });
                 // Return a new object that combines the properties of the item and the template
-                // return { ...item, ...template };  
+                return Object.assign(Object.assign({}, item), template);
                 return item;
             });
             return data;
@@ -129,8 +132,14 @@ class EmblemVaultSDK {
                 callback(`creating Vault for user`, template.toAddress);
             }
             let vaultCreationResponse = yield (0, utils_1.fetchData)(url, this.apiKey, 'POST', template);
+            if (vaultCreationResponse === null || vaultCreationResponse === void 0 ? void 0 : vaultCreationResponse.err) {
+                if (callback)
+                    callback(`error creating Vault: ${vaultCreationResponse.msg}`);
+                return vaultCreationResponse;
+            }
+            const { tokenId } = vaultCreationResponse.data;
             if (callback) {
-                callback(`created Vault tokenId`, vaultCreationResponse.data.tokenId);
+                callback(`created Vault ${tokenId}`);
             }
             return vaultCreationResponse.data;
         });
@@ -185,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";
@@ -581,6 +640,50 @@ class EmblemVaultSDK {
             return results;
         });
     }
+    // ========================================================================
+    // Remote Signer Methods (EmblemVaultClient) - Multi-Chain Support
+    // ========================================================================
+    getSdkContext() {
+        return {
+            apiKey: this.apiKey,
+            baseUrl: this.baseUrl,
+            v3Url: this.v3Url,
+            sigUrl: this.sigUrl,
+            fetchMetadata: this.fetchMetadata.bind(this),
+            requestRemoteKey: this.requestRemoteKey.bind(this),
+            decryptVaultKeys: this.decryptVaultKeys.bind(this),
+        };
+    }
+    performMintChainWithClient(client_1, tokenId_1) {
+        return __awaiter(this, arguments, void 0, function* (client, tokenId, chainId = constants_1.ETHEREUM_MAINNET_CHAIN_ID, callback) {
+            (0, utils_1.genericGuard)(tokenId, "string", "tokenId");
+            (0, vault_utils_1.getChainConfig)(chainId);
+            return (0, evm_operations_1.performMintEvm)(this.getSdkContext(), client, tokenId, chainId, callback);
+        });
+    }
+    performClaimChainWithClient(client_1, tokenId_1) {
+        return __awaiter(this, arguments, void 0, function* (client, tokenId, chainId = constants_1.ETHEREUM_MAINNET_CHAIN_ID, callback) {
+            var _a, _b;
+            (0, utils_1.genericGuard)(tokenId, "string", "tokenId");
+            (0, vault_utils_1.getChainConfig)(chainId);
+            callback === null || callback === void 0 ? void 0 : callback('Fetching vault metadata...');
+            const metadata = yield this.fetchMetadata(tokenId, callback);
+            const claimIdentifier = (0, vault_utils_1.getClaimIdentifier)(metadata);
+            // Check if this is a V2 vault by checking the deployment type (matches VaultActions.vue logic)
+            // metadata[chainId]?.type?.endsWith('V2') indicates a diamond/V2 contract
+            const deploymentInfo = metadata === null || metadata === void 0 ? void 0 : metadata[chainId];
+            const vaultIsV2 = Boolean((_b = (_a = deploymentInfo === null || deploymentInfo === void 0 ? void 0 : deploymentInfo.type) === null || _a === void 0 ? void 0 : _a.endsWith) === null || _b === void 0 ? void 0 : _b.call(_a, 'V2'));
+            const needsOnChainUnvault = (0, vault_utils_1.requiresOnChainUnvault)(metadata) && vaultIsV2;
+            return (0, evm_operations_1.performClaimEvm)(this.getSdkContext(), client, tokenId, chainId, metadata, claimIdentifier, vaultIsV2, needsOnChainUnvault, callback);
+        });
+    }
+    deleteVaultWithClient(client_1, tokenId_1) {
+        return __awaiter(this, arguments, void 0, function* (client, tokenId, chainId = constants_1.ETHEREUM_MAINNET_CHAIN_ID, callback) {
+            (0, utils_1.genericGuard)(tokenId, "string", "tokenId");
+            (0, vault_utils_1.getChainConfig)(chainId);
+            return (0, evm_operations_1.deleteVaultEvm)(client, tokenId, chainId, callback);
+        });
+    }
     // BTC
     sweepVaultUsingPhrase(phrase_1) {
         return __awaiter(this, arguments, void 0, function* (phrase, satsPerByte = 20, broadcast = false) {

package/dist/signing-messages.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMintMessage = buildMintMessage;
+exports.buildClaimMessage = buildClaimMessage;
+exports.buildUnvaultMessage = buildUnvaultMessage;
+exports.buildDeleteMessage = buildDeleteMessage;
+function buildMintMessage(tokenId) {
+    return `Curated Minting: ${tokenId}`;
+}
+function buildClaimMessage(identifier, isV2Vault) {
+    const prefix = isV2Vault ? 'Unvault' : 'Claim';
+    return `${prefix}: ${identifier}`;
+}
+function buildUnvaultMessage(identifier) {
+    return `Unvault: ${identifier}`;
+}
+function buildDeleteMessage(tokenId) {
+    return `Delete: ${tokenId}`;
+}

package/dist/utils.js

@@ -26,6 +26,7 @@ exports.getTorusKeys = getTorusKeys;
 exports.decryptKeys = decryptKeys;
 exports.getSatsConnectAddress = getSatsConnectAddress;
 exports.signPSBT = signPSBT;
+exports.parseBigIntValue = parseBigIntValue;
 const crypto_js_1 = __importDefault(require("crypto-js"));
 const metadata_json_1 = __importDefault(require("./curated/metadata.json"));
 const darkfarms_metadata_json_1 = __importDefault(require("./curated/darkfarms-metadata.json"));
@@ -596,6 +597,39 @@ function generateTemplate(record) {
             nameAndImage.description = nameAndImage.description + viewOnEmblemFinanceLink;
             return nameAndImage;
         },
+        fillCreateVaultTemplate: (args, _this) => {
+            const template = _this.generateCreateTemplate(_this);
+            if (args.fromAddress) {
+                template.fromAddress = args.fromAddress;
+            }
+            else {
+                throw new Error("fromAddress is required to create vault");
+            }
+            if (args.toAddress) {
+                template.toAddress = args.toAddress;
+            }
+            else {
+                throw new Error("toAddress is required to create vault");
+            }
+            if (args.chainId) {
+                const chainIdAsString = String(args.chainId);
+                template.targetContract = {
+                    name: template.targetContract.name,
+                    [chainIdAsString]: template.targetContract[chainIdAsString]
+                };
+                template.chainId = args.chainId;
+            }
+            else {
+                throw new Error("chainId is required to create vault");
+            }
+            if (args.targetAsset) {
+                Object.assign(template.targetAsset, args.targetAsset);
+            }
+            else {
+                template.targetAsset = undefined;
+            }
+            return template;
+        },
         generateCreateTemplate: (_this) => {
             let template = {
                 fromAddress: { type: "user-provided" },
@@ -952,3 +986,9 @@ function signPSBT(psbtBase64_1, paymentAddress_1, indexes_1) {
         });
     });
 }
+function parseBigIntValue(value) {
+    if (typeof value === 'object' && value !== null && 'hex' in value) {
+        return BigInt(value.hex);
+    }
+    return BigInt(String(value));
+}

package/dist/vault-utils.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isV2Vault = isV2Vault;
+exports.requiresOnChainUnvault = requiresOnChainUnvault;
+exports.getClaimIdentifier = getClaimIdentifier;
+exports.getHandlerContractAddress = getHandlerContractAddress;
+exports.getUnvaultingContractAddress = getUnvaultingContractAddress;
+exports.getChainConfig = getChainConfig;
+exports.isEvmChain = isEvmChain;
+const constants_1 = require("./constants");
+function isV2Vault(metadata) {
+    var _a;
+    return Boolean((_a = metadata.targetContract) === null || _a === void 0 ? void 0 : _a.name);
+}
+function requiresOnChainUnvault(metadata) {
+    return metadata.status === 'unclaimed' && !metadata.sealed && Boolean(metadata.live);
+}
+/**
+ * Get the claim identifier for signing claim messages.
+ * This MUST match VaultActions.vue's getSerialNumber() logic:
+ * - ERC1155: use targetContract.serialNumber
+ * - ERC721a: use tokenId
+ * - Legacy: use tokenId
+ */
+function getClaimIdentifier(metadata) {
+    const { targetContract, ownershipInfo, tokenId } = metadata;
+    // If no targetContract, fallback to tokenId
+    if (!targetContract) {
+        return tokenId || '';
+    }
+    // ERC1155: use serialNumber
+    if (targetContract.collectionType === 'ERC1155' ||
+        (ownershipInfo === null || ownershipInfo === void 0 ? void 0 : ownershipInfo.category) === 'erc1155') {
+        return targetContract.serialNumber || tokenId || '';
+    }
+    // ERC721a: use tokenId (NOT serialNumber!)
+    if (targetContract.collectionType === 'ERC721a' ||
+        (ownershipInfo === null || ownershipInfo === void 0 ? void 0 : ownershipInfo.category) === 'erc721a') {
+        return tokenId || '';
+    }
+    // Default: use targetContract.tokenId or tokenId
+    return targetContract.tokenId || tokenId || '';
+}
+function getHandlerContractAddress(chainId) {
+    const config = getChainConfig(chainId);
+    if (!config.handlerContract) {
+        throw new Error(`No handler contract configured for chain ${chainId}`);
+    }
+    return config.handlerContract;
+}
+function getUnvaultingContractAddress(chainId) {
+    const config = getChainConfig(chainId);
+    if (!config.unvaultingContract) {
+        throw new Error(`No unvaulting contract configured for chain ${chainId}`);
+    }
+    return config.unvaultingContract;
+}
+function getChainConfig(chainId) {
+    const config = constants_1.SUPPORTED_CHAINS[chainId];
+    if (!config) {
+        const supportedList = Object.entries(constants_1.SUPPORTED_CHAINS)
+            .map(([id, cfg]) => `${cfg.name} (${id})`)
+            .join(', ');
+        throw new Error(`Unsupported chain: ${chainId}. Supported chains: ${supportedList}`);
+    }
+    return config;
+}
+function isEvmChain(chainId) {
+    const config = constants_1.SUPPORTED_CHAINS[chainId];
+    return (config === null || config === void 0 ? void 0 : config.type) === 'evm';
+}