emblem-vault-sdk 2.11.0 → 2.12.0

package/dist/abi/abi.json

@@ -78,18 +78,18 @@
             "inputs": [
                 {
                     "internalType": "address",
-                    "name": "_nftAddress",
+                    "name": "",
                     "type": "address"
                 },
                 {
                     "internalType": "uint256",
-                    "name": "tokenId",
+                    "name": "",
                     "type": "uint256"
                 }
             ],
             "name": "claim",
             "outputs": [],
-            "stateMutability": "nonpayable",
+            "stateMutability": "pure",
             "type": "function"
         },
         {
@@ -144,6 +144,82 @@
             "outputs": [],
             "stateMutability": "payable",
             "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "_nftAddress",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "tokenId",
+                    "type": "uint256"
+                },
+                {
+                    "internalType": "address",
+                    "name": "_payment",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "_price",
+                    "type": "uint256"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "_nonce",
+                    "type": "uint256"
+                },
+                {
+                    "internalType": "bytes",
+                    "name": "_signature",
+                    "type": "bytes"
+                }
+            ],
+            "name": "claimWithSignedPrice",
+            "outputs": [],
+            "stateMutability": "payable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "internalType": "address[]",
+                    "name": "nftAddresses",
+                    "type": "address[]"
+                },
+                {
+                    "internalType": "uint256[]",
+                    "name": "tokenIds",
+                    "type": "uint256[]"
+                },
+                {
+                    "internalType": "address",
+                    "name": "_payment",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "_price",
+                    "type": "uint256"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "_nonce",
+                    "type": "uint256"
+                },
+                {
+                    "internalType": "bytes",
+                    "name": "_signature",
+                    "type": "bytes"
+                }
+            ],
+            "name": "batchClaimWithSignedPrice",
+            "outputs": [],
+            "stateMutability": "payable",
+            "type": "function"
         }
     ],
     "legacy": [

package/dist/evm-operations.js

@@ -45,6 +45,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.performMintEvm = performMintEvm;
 exports.performClaimEvm = performClaimEvm;
 exports.deleteVaultEvm = deleteVaultEvm;
+exports.performBatchClaimEvm = performBatchClaimEvm;
 const constants_1 = require("./constants");
 const signing_messages_1 = require("./signing-messages");
 const vault_utils_1 = require("./vault-utils");
@@ -97,7 +98,7 @@ function performClaimEvm(ctx, client, tokenId, chainId, metadata, claimIdentifie
                 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);
+                    yield performLegacyClaim(ctx, wallet, targetContractAddress, claimIdentifier, chainId, callback);
                 }
             }
         }
@@ -211,29 +212,117 @@ function performOnChainUnvault(ctx, wallet, tokenId, claimIdentifier, nftAddress
  * 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) {
+function performLegacyClaim(ctx, 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
+        // The handler's free claim(address,uint256) was retired; claiming requires a
+        // witness-signed price via claimWithSignedPrice. Sign "Claim: <tokenId>", get
+        // the server-signed price for this asset (supply tier), then call the contract
+        // with the server-derived on-chain tokenId + payment.
+        callback === null || callback === void 0 ? void 0 : callback('Signing claim authorization...');
+        const claimSig = yield wallet.signMessage(`Claim: ${tokenId}`);
+        callback === null || callback === void 0 ? void 0 : callback('Requesting claim price...');
+        const remote = yield requestRemoteClaimSignature(ctx, tokenId, claimSig, chainId);
         const HANDLER_CLAIM_ABI = [
-            'function claim(address _nftAddress, uint256 _tokenId) external'
+            'function claimWithSignedPrice(address _nftAddress, uint256 tokenId, address _payment, uint256 _price, uint256 _nonce, bytes _signature) external payable'
         ];
         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),
+        const price = ethers.BigNumber.from(remote._price);
+        const isEth = remote._payment === '0x0000000000000000000000000000000000000000';
+        const data = iface.encodeFunctionData('claimWithSignedPrice', [
+            remote._nftAddress,
+            ethers.BigNumber.from(remote._tokenId),
+            remote._payment,
+            price,
+            ethers.BigNumber.from(remote._nonce),
+            remote._signature,
         ]);
         callback === null || callback === void 0 ? void 0 : callback('Submitting claim transaction...');
         const tx = yield wallet.sendTransaction({
             to: handlerAddress,
             data,
+            value: isEth ? price : ethers.constants.Zero,
         });
         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!');
     });
 }
+// Witness signature + supply-tier price for a legacy (non-diamond) claim.
+function requestRemoteClaimSignature(ctx, tokenId, signature, chainId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch(`${ctx.baseUrl}/claim-curated`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ tokenId, signature, chainId: chainId.toString() }),
+        });
+        const remote = yield response.json();
+        if (!(remote === null || remote === void 0 ? void 0 : remote.success)) {
+            throw new Error((remote === null || remote === void 0 ? void 0 : remote.msg) || (remote === null || remote === void 0 ? void 0 : remote.error) || 'Failed to get claim signature');
+        }
+        return remote;
+    });
+}
+// Batch witness signature + summed supply-tier price for several vaults.
+function requestRemoteBatchClaimSignature(ctx, tokenIds, signature, chainId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch(`${ctx.baseUrl}/claim-curated-bulk`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ tokenIds, signature, chainId: chainId.toString() }),
+        });
+        const remote = yield response.json();
+        if (!(remote === null || remote === void 0 ? void 0 : remote.success)) {
+            throw new Error((remote === null || remote === void 0 ? void 0 : remote.msg) || (remote === null || remote === void 0 ? void 0 : remote.error) || 'Failed to get batch claim signature');
+        }
+        return remote;
+    });
+}
+// Client path: burn several vaults in one tx via batchClaimWithSignedPrice. Only
+// performs the on-chain claim (Step 1) for the batch; reveal each vault's keys
+// with performClaimChainWithClient afterward (which will skip Step 1 as claimed).
+function performBatchClaimEvm(ctx, client, tokenIds, 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);
+        // One wallet signature over the sorted, comma-joined ids (order-independent).
+        const sorted = [...tokenIds.map(String)].sort().join(',');
+        callback === null || callback === void 0 ? void 0 : callback('Signing batch claim authorization...');
+        const signature = yield wallet.signMessage(`Claim: ${sorted}`);
+        callback === null || callback === void 0 ? void 0 : callback('Requesting batch claim price...');
+        const remote = yield requestRemoteBatchClaimSignature(ctx, tokenIds, signature, chainId);
+        const HANDLER_BATCH_ABI = [
+            'function batchClaimWithSignedPrice(address[] nftAddresses, uint256[] tokenIds, address _payment, uint256 _price, uint256 _nonce, bytes _signature) external payable'
+        ];
+        const handlerAddress = (0, vault_utils_1.getHandlerContractAddress)(chainId);
+        const iface = new ethers.utils.Interface(HANDLER_BATCH_ABI);
+        const price = ethers.BigNumber.from(remote._price);
+        const isEth = remote._payment === constants_1.ZERO_ADDRESS;
+        const data = iface.encodeFunctionData('batchClaimWithSignedPrice', [
+            remote._nftAddresses,
+            remote._tokenIds.map((t) => ethers.BigNumber.from(t)),
+            remote._payment,
+            price,
+            ethers.BigNumber.from(remote._nonce),
+            remote._signature,
+        ]);
+        callback === null || callback === void 0 ? void 0 : callback('Submitting batch claim transaction...');
+        const tx = yield wallet.sendTransaction({
+            to: handlerAddress,
+            data,
+            value: isEth ? price : ethers.constants.Zero,
+        });
+        callback === null || callback === void 0 ? void 0 : callback('Waiting for batch claim confirmation...', { txHash: tx.hash });
+        yield tx.wait();
+        callback === null || callback === void 0 ? void 0 : callback('On-chain batch claim complete!');
+        return { txHash: tx.hash };
+    });
+}
 function requestRemoteUnvaultSignature(ctx, tokenId, signature, chainId) {
     return __awaiter(this, void 0, void 0, function* () {
         const response = yield fetch(`${ctx.baseUrl}/unvault-curated`, {

package/dist/index.js

@@ -48,7 +48,7 @@ const derive_1 = require("./derive");
 const constants_1 = require("./constants");
 const vault_utils_1 = require("./vault-utils");
 const evm_operations_1 = require("./evm-operations");
-const SDK_VERSION = '2.11.0';
+const SDK_VERSION = '2.12.0';
 class EmblemVaultSDK {
     constructor(apiKey, baseUrl, v3Url, sigUrl) {
         this.apiKey = apiKey;
@@ -455,6 +455,25 @@ class EmblemVaultSDK {
             return remoteMintResponse;
         });
     }
+    // Witness signature + supply-tier price for a claim (the on-chain burn before
+    // key reveal). `signature` is the user's "Claim: <tokenId>" wallet signature.
+    requestRemoteClaimSignature(web3_1, tokenId_1, signature_1) {
+        return __awaiter(this, arguments, void 0, function* (web3, tokenId, signature, callback = null) {
+            if (callback) {
+                callback('requesting Remote Claim signature');
+            }
+            const chainId = yield web3.eth.getChainId();
+            let url = `${this.baseUrl}/claim-curated`;
+            let remoteClaimResponse = yield (0, utils_1.fetchData)(url, this.apiKey, 'POST', { tokenId: tokenId, signature: signature, chainId: chainId.toString() });
+            if (remoteClaimResponse.error || remoteClaimResponse.err) {
+                throw new Error(remoteClaimResponse.error || remoteClaimResponse.msg || 'Failed to get claim signature');
+            }
+            if (callback) {
+                callback(`remote Claim signature`, remoteClaimResponse);
+            }
+            return remoteClaimResponse;
+        });
+    }
     // ** Bulk Mint **
     //
     // Builds the deterministic message a user signs to authorize a bulk curated
@@ -639,24 +658,25 @@ class EmblemVaultSDK {
     }
     performBurn(web3_1, tokenId_1) {
         return __awaiter(this, arguments, void 0, function* (web3, tokenId, callback = null) {
-            let metadata = yield this.fetchMetadata(tokenId);
-            let targetContract = yield this.fetchCuratedContractByName(metadata.targetContract.name);
             if (callback) {
                 callback('performing Burn');
             }
             const accounts = yield web3.eth.getAccounts();
-            const chainId = yield web3.eth.getChainId();
             let handlerContract = yield (0, utils_1.getHandlerContract)(web3);
-            // Dynamically fetch the current gas price
+            // The handler no longer has a free claim(address,uint256); claiming requires
+            // a witness-signed price via claimWithSignedPrice. Get the user's "Claim:"
+            // signature, then the server-signed price for this asset (supply tier), then
+            // call claimWithSignedPrice with the server-derived on-chain tokenId + payment.
+            const claimSig = yield this.requestLocalClaimSignature(web3, tokenId, null, callback);
+            const remote = yield this.requestRemoteClaimSignature(web3, tokenId, claimSig, callback);
+            const price = remote._price;
+            const isEth = remote._payment === '0x0000000000000000000000000000000000000000';
             const gasPrice = yield web3.eth.getGasPrice();
-            let createdTxObject = handlerContract.methods.claim(targetContract[chainId], targetContract.collectionType == 'ERC721a' ? tokenId : targetContract.tokenId);
-            // Estimate gas limit for the transaction
-            const estimatedGas = yield createdTxObject.estimateGas({ from: accounts[0] });
-            let burnResponse = yield createdTxObject.send({
-                from: accounts[0],
-                gasPrice: gasPrice,
-                gas: estimatedGas
-            }).on('transactionHash', (hash) => {
+            let createdTxObject = handlerContract.methods.claimWithSignedPrice(remote._nftAddress, remote._tokenId, remote._payment, price, remote._nonce, remote._signature);
+            const sendOpts = { from: accounts[0], gasPrice, value: isEth ? price : '0' };
+            sendOpts.gas = yield createdTxObject.estimateGas(sendOpts);
+            let burnResponse = yield createdTxObject.send(sendOpts)
+                .on('transactionHash', (hash) => {
                 if (callback)
                     callback(`Transaction submitted. Hash`, hash);
             })
@@ -674,6 +694,71 @@ class EmblemVaultSDK {
             return burnResponse;
         });
     }
+    // Wallet signature authorizing a batch claim. Must match the server's expected
+    // message: "Claim: <sorted tokenIds joined by ','>" (order-independent).
+    requestLocalBatchClaimSignature(web3_1, tokenIds_1) {
+        return __awaiter(this, arguments, void 0, function* (web3, tokenIds, callback = null) {
+            if (callback) {
+                callback('requesting User Batch Claim Signature');
+            }
+            const sorted = [...tokenIds.map(String)].sort().join(',');
+            const message = `Claim: ${sorted}`;
+            const accounts = yield web3.eth.getAccounts();
+            const signature = yield web3.eth.personal.sign(message, accounts[0], '');
+            return signature;
+        });
+    }
+    // Fetch the batch witness signature + summed supply-tier price for several vaults.
+    requestRemoteBatchClaimSignature(web3_1, tokenIds_1, signature_1) {
+        return __awaiter(this, arguments, void 0, function* (web3, tokenIds, signature, callback = null) {
+            if (callback) {
+                callback('requesting Remote Batch Claim signature');
+            }
+            const chainId = yield web3.eth.getChainId();
+            let url = `${this.baseUrl}/claim-curated-bulk`;
+            let remote = yield (0, utils_1.fetchData)(url, this.apiKey, 'POST', { tokenIds, signature, chainId: chainId.toString() });
+            if (remote.error || remote.err || remote.success === false) {
+                throw new Error(remote.error || remote.msg || 'Failed to get batch claim signature');
+            }
+            return remote;
+        });
+    }
+    // Burn several vaults in one tx via batchClaimWithSignedPrice. One wallet
+    // signature + one witness signature + summed supply-tier price for the batch.
+    performBatchBurn(web3_1, tokenIds_1) {
+        return __awaiter(this, arguments, void 0, function* (web3, tokenIds, callback = null) {
+            if (callback) {
+                callback('performing Batch Burn');
+            }
+            const accounts = yield web3.eth.getAccounts();
+            let handlerContract = yield (0, utils_1.getHandlerContract)(web3);
+            const claimSig = yield this.requestLocalBatchClaimSignature(web3, tokenIds, callback);
+            const remote = yield this.requestRemoteBatchClaimSignature(web3, tokenIds, claimSig, callback);
+            const price = remote._price;
+            const isEth = remote._payment === '0x0000000000000000000000000000000000000000';
+            const value = isEth ? price : '0';
+            const gasPrice = yield web3.eth.getGasPrice();
+            let createdTxObject = handlerContract.methods.batchClaimWithSignedPrice(remote._nftAddresses, remote._tokenIds, remote._payment, price, remote._nonce, remote._signature);
+            const gas = yield createdTxObject.estimateGas({ from: accounts[0], value });
+            let burnResponse = yield createdTxObject.send({ from: accounts[0], value, gasPrice, gas })
+                .on('transactionHash', (hash) => {
+                if (callback)
+                    callback(`Transaction submitted. Hash`, hash);
+            })
+                .on('confirmation', (confirmationNumber, receipt) => {
+                if (callback)
+                    callback(`Batch Burn Complete. Confirmation Number`, confirmationNumber);
+            })
+                .on('error', (error) => {
+                if (callback)
+                    callback(`Transaction Error`, error.message);
+            });
+            if (callback) {
+                callback('Batch Burn Complete');
+            }
+            return burnResponse;
+        });
+    }
     contentTypeReport(url) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield (0, utils_1.checkContentType)(url);
@@ -768,6 +853,14 @@ class EmblemVaultSDK {
             return (0, evm_operations_1.performClaimEvm)(this.getSdkContext(), client, tokenId, chainId, metadata, claimIdentifier, vaultIsV2, needsOnChainUnvault, callback);
         });
     }
+    // Client-path batch claim: burn several vaults in one tx (Step 1 only). Reveal
+    // each vault's keys afterward with performClaimChainWithClient (skips Step 1).
+    performBatchBurnWithClient(client_1, tokenIds_1) {
+        return __awaiter(this, arguments, void 0, function* (client, tokenIds, chainId = constants_1.ETHEREUM_MAINNET_CHAIN_ID, callback) {
+            (0, vault_utils_1.getChainConfig)(chainId);
+            return (0, evm_operations_1.performBatchClaimEvm)(this.getSdkContext(), client, tokenIds, chainId, 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");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emblem-vault-sdk",
-  "version": "2.11.0",
+  "version": "2.12.0",
   "description": "Emblem Vault Software Development Kit",
   "main": "dist/index.js",
   "files": [
@@ -61,4 +61,4 @@
   "engines": {
     "node": ">=20.5.1"
   }
-}
+}

package/src/abi/abi.json

@@ -78,18 +78,18 @@
       "inputs": [
         {
           "internalType": "address",
-          "name": "_nftAddress",
+          "name": "",
           "type": "address"
         },
         {
           "internalType": "uint256",
-          "name": "tokenId",
+          "name": "",
           "type": "uint256"
         }
       ],
       "name": "claim",
       "outputs": [],
-      "stateMutability": "nonpayable",
+      "stateMutability": "pure",
       "type": "function"
     },
     {
@@ -144,6 +144,82 @@
       "outputs": [],
       "stateMutability": "payable",
       "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "_nftAddress",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "tokenId",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "_payment",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "_price",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "_nonce",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bytes",
+          "name": "_signature",
+          "type": "bytes"
+        }
+      ],
+      "name": "claimWithSignedPrice",
+      "outputs": [],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address[]",
+          "name": "nftAddresses",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256[]",
+          "name": "tokenIds",
+          "type": "uint256[]"
+        },
+        {
+          "internalType": "address",
+          "name": "_payment",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "_price",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "_nonce",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bytes",
+          "name": "_signature",
+          "type": "bytes"
+        }
+      ],
+      "name": "batchClaimWithSignedPrice",
+      "outputs": [],
+      "stateMutability": "payable",
+      "type": "function"
     }
   ],
   "legacy": [

package/src/evm-operations.ts

@@ -105,7 +105,7 @@ export async function performClaimEvm(
             const targetContractAddress = metadata.targetContract?.[chainId] || metadata.collectionAddress;
             if (targetContractAddress) {
                 callback?.('Performing on-chain claim...');
-                await performLegacyClaim(wallet, targetContractAddress, claimIdentifier, chainId, callback);
+                await performLegacyClaim(ctx, wallet, targetContractAddress, claimIdentifier, chainId, callback);
             }
         }
     }
@@ -262,6 +262,7 @@ async function performOnChainUnvault(
  * This is for non-V2 vaults that don't use signed price unvaulting
  */
 async function performLegacyClaim(
+    ctx: SdkContext,
     wallet: EvmSigner,
     targetContractAddress: string,
     tokenId: string,
@@ -269,32 +270,141 @@ async function performLegacyClaim(
     callback?: ProgressCallback
 ): Promise<void> {
     const { ethers } = await import('ethers');
-    
-    // Handler contract ABI for claim function
+
+    // The handler's free claim(address,uint256) was retired; claiming requires a
+    // witness-signed price via claimWithSignedPrice. Sign "Claim: <tokenId>", get
+    // the server-signed price for this asset (supply tier), then call the contract
+    // with the server-derived on-chain tokenId + payment.
+    callback?.('Signing claim authorization...');
+    const claimSig = await wallet.signMessage(`Claim: ${tokenId}`);
+
+    callback?.('Requesting claim price...');
+    const remote = await requestRemoteClaimSignature(ctx, tokenId, claimSig, chainId);
+
     const HANDLER_CLAIM_ABI = [
-        'function claim(address _nftAddress, uint256 _tokenId) external'
+        'function claimWithSignedPrice(address _nftAddress, uint256 tokenId, address _payment, uint256 _price, uint256 _nonce, bytes _signature) external payable'
     ];
-    
     const handlerAddress = getHandlerContractAddress(chainId);
     const iface = new ethers.utils.Interface(HANDLER_CLAIM_ABI);
-    
-    const data = iface.encodeFunctionData('claim', [
-        targetContractAddress,
-        BigInt(tokenId),
+
+    const price = ethers.BigNumber.from(remote._price);
+    const isEth = remote._payment === '0x0000000000000000000000000000000000000000';
+
+    const data = iface.encodeFunctionData('claimWithSignedPrice', [
+        remote._nftAddress,
+        ethers.BigNumber.from(remote._tokenId),
+        remote._payment,
+        price,
+        ethers.BigNumber.from(remote._nonce),
+        remote._signature,
     ]);
 
     callback?.('Submitting claim transaction...');
     const tx = await wallet.sendTransaction({
         to: handlerAddress,
         data,
+        value: isEth ? price : ethers.constants.Zero,
     });
 
     callback?.('Waiting for claim confirmation...', { txHash: tx.hash });
     await tx.wait();
-    
+
     callback?.('On-chain claim complete!');
 }
 
+// Witness signature + supply-tier price for a legacy (non-diamond) claim.
+async function requestRemoteClaimSignature(
+    ctx: SdkContext,
+    tokenId: string,
+    signature: string,
+    chainId: number
+): Promise<any> {
+    const response = await fetch(`${ctx.baseUrl}/claim-curated`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ tokenId, signature, chainId: chainId.toString() }),
+    });
+    const remote = await response.json();
+    if (!remote?.success) {
+        throw new Error(remote?.msg || remote?.error || 'Failed to get claim signature');
+    }
+    return remote;
+}
+
+// Batch witness signature + summed supply-tier price for several vaults.
+async function requestRemoteBatchClaimSignature(
+    ctx: SdkContext,
+    tokenIds: string[],
+    signature: string,
+    chainId: number
+): Promise<any> {
+    const response = await fetch(`${ctx.baseUrl}/claim-curated-bulk`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ tokenIds, signature, chainId: chainId.toString() }),
+    });
+    const remote = await response.json();
+    if (!remote?.success) {
+        throw new Error(remote?.msg || remote?.error || 'Failed to get batch claim signature');
+    }
+    return remote;
+}
+
+// Client path: burn several vaults in one tx via batchClaimWithSignedPrice. Only
+// performs the on-chain claim (Step 1) for the batch; reveal each vault's keys
+// with performClaimChainWithClient afterward (which will skip Step 1 as claimed).
+export async function performBatchClaimEvm(
+    ctx: SdkContext,
+    client: EmblemVaultClient,
+    tokenIds: string[],
+    chainId: number,
+    callback?: ProgressCallback
+): Promise<{ txHash: string }> {
+    callback?.('Initializing EVM signer...');
+    const { ethers } = await import('ethers');
+    const provider = new ethers.providers.JsonRpcProvider(getEvmRpcUrl(chainId));
+    const wallet = await client.toEthersWallet(provider);
+    wallet.setChainId?.(chainId);
+
+    // One wallet signature over the sorted, comma-joined ids (order-independent).
+    const sorted = [...tokenIds.map(String)].sort().join(',');
+    callback?.('Signing batch claim authorization...');
+    const signature = await wallet.signMessage(`Claim: ${sorted}`);
+
+    callback?.('Requesting batch claim price...');
+    const remote = await requestRemoteBatchClaimSignature(ctx, tokenIds, signature, chainId);
+
+    const HANDLER_BATCH_ABI = [
+        'function batchClaimWithSignedPrice(address[] nftAddresses, uint256[] tokenIds, address _payment, uint256 _price, uint256 _nonce, bytes _signature) external payable'
+    ];
+    const handlerAddress = getHandlerContractAddress(chainId);
+    const iface = new ethers.utils.Interface(HANDLER_BATCH_ABI);
+
+    const price = ethers.BigNumber.from(remote._price);
+    const isEth = remote._payment === ZERO_ADDRESS;
+
+    const data = iface.encodeFunctionData('batchClaimWithSignedPrice', [
+        remote._nftAddresses,
+        remote._tokenIds.map((t: string) => ethers.BigNumber.from(t)),
+        remote._payment,
+        price,
+        ethers.BigNumber.from(remote._nonce),
+        remote._signature,
+    ]);
+
+    callback?.('Submitting batch claim transaction...');
+    const tx = await wallet.sendTransaction({
+        to: handlerAddress,
+        data,
+        value: isEth ? price : ethers.constants.Zero,
+    });
+
+    callback?.('Waiting for batch claim confirmation...', { txHash: tx.hash });
+    await tx.wait();
+    callback?.('On-chain batch claim complete!');
+    return { txHash: tx.hash };
+}
+
 async function requestRemoteUnvaultSignature(
     ctx: SdkContext,
     tokenId: string,

package/src/index.ts

@@ -24,7 +24,7 @@ import {
     requiresOnChainUnvault,
     getClaimIdentifier,
 } from './vault-utils';
-import { performMintEvm, performClaimEvm, deleteVaultEvm } from './evm-operations';
+import { performMintEvm, performClaimEvm, performBatchClaimEvm, deleteVaultEvm } from './evm-operations';
 
 const SDK_VERSION = '__SDK_VERSION__'; 
 
@@ -401,6 +401,20 @@ class EmblemVaultSDK {
         return remoteMintResponse
     }
 
+    // Witness signature + supply-tier price for a claim (the on-chain burn before
+    // key reveal). `signature` is the user's "Claim: <tokenId>" wallet signature.
+    async requestRemoteClaimSignature(web3: any, tokenId: string, signature: string, callback: any = null) {
+        if (callback) { callback('requesting Remote Claim signature')}
+        const chainId = await web3.eth.getChainId();
+        let url = `${this.baseUrl}/claim-curated`;
+        let remoteClaimResponse = await fetchData(url, this.apiKey, 'POST', {tokenId: tokenId, signature: signature, chainId: chainId.toString()});
+        if (remoteClaimResponse.error || remoteClaimResponse.err) {
+            throw new Error(remoteClaimResponse.error || remoteClaimResponse.msg || 'Failed to get claim signature')
+        }
+        if (callback) { callback(`remote Claim signature`, remoteClaimResponse)}
+        return remoteClaimResponse
+    }
+
     // ** Bulk Mint **
     //
     // Builds the deterministic message a user signs to authorize a bulk curated
@@ -567,25 +581,34 @@ class EmblemVaultSDK {
         
 
     async performBurn(web3: any, tokenId: any, callback: any = null) {
-        let metadata: any = await this.fetchMetadata(tokenId);
-        let targetContract: any = await this.fetchCuratedContractByName(metadata.targetContract.name);
         if (callback) { callback('performing Burn')}
         const accounts = await web3.eth.getAccounts();
-        const chainId = await web3.eth.getChainId();
         let handlerContract = await getHandlerContract(web3);
-    
-        // Dynamically fetch the current gas price
+
+        // The handler no longer has a free claim(address,uint256); claiming requires
+        // a witness-signed price via claimWithSignedPrice. Get the user's "Claim:"
+        // signature, then the server-signed price for this asset (supply tier), then
+        // call claimWithSignedPrice with the server-derived on-chain tokenId + payment.
+        const claimSig = await this.requestLocalClaimSignature(web3, tokenId, null, callback);
+        const remote = await this.requestRemoteClaimSignature(web3, tokenId, claimSig, callback);
+
+        const price = remote._price;
+        const isEth = remote._payment === '0x0000000000000000000000000000000000000000';
+
         const gasPrice = await web3.eth.getGasPrice();
-        
-        let createdTxObject = handlerContract.methods.claim(targetContract[chainId], targetContract.collectionType == 'ERC721a' ? tokenId : targetContract.tokenId) 
-        // Estimate gas limit for the transaction
-        const estimatedGas = await createdTxObject.estimateGas({from: accounts[0]});
-    
-        let burnResponse = await createdTxObject.send({
-            from: accounts[0],
-            gasPrice: gasPrice,
-            gas: estimatedGas
-        }).on('transactionHash', (hash: any) => {
+        let createdTxObject = handlerContract.methods.claimWithSignedPrice(
+            remote._nftAddress,
+            remote._tokenId,
+            remote._payment,
+            price,
+            remote._nonce,
+            remote._signature
+        );
+        const sendOpts: any = { from: accounts[0], gasPrice, value: isEth ? price : '0' };
+        sendOpts.gas = await createdTxObject.estimateGas(sendOpts);
+
+        let burnResponse = await createdTxObject.send(sendOpts)
+        .on('transactionHash', (hash: any) => {
             if (callback) callback(`Transaction submitted. Hash`, hash);
         })
         .on('confirmation', (confirmationNumber: any, receipt: any) => {
@@ -594,11 +617,74 @@ class EmblemVaultSDK {
         .on('error', (error: { message: any; }) => {
             if (callback) callback(`Transaction Error`, error.message );
         });
-    
+
         if (callback) { callback('Burn Complete')}
         return burnResponse;
     }
-    
+
+    // Wallet signature authorizing a batch claim. Must match the server's expected
+    // message: "Claim: <sorted tokenIds joined by ','>" (order-independent).
+    async requestLocalBatchClaimSignature(web3: any, tokenIds: string[], callback: any = null) {
+        if (callback) { callback('requesting User Batch Claim Signature') }
+        const sorted = [...tokenIds.map(String)].sort().join(',');
+        const message = `Claim: ${sorted}`;
+        const accounts = await web3.eth.getAccounts();
+        const signature = await web3.eth.personal.sign(message, accounts[0], '');
+        return signature;
+    }
+
+    // Fetch the batch witness signature + summed supply-tier price for several vaults.
+    async requestRemoteBatchClaimSignature(web3: any, tokenIds: string[], signature: string, callback: any = null) {
+        if (callback) { callback('requesting Remote Batch Claim signature') }
+        const chainId = await web3.eth.getChainId();
+        let url = `${this.baseUrl}/claim-curated-bulk`;
+        let remote = await fetchData(url, this.apiKey, 'POST', { tokenIds, signature, chainId: chainId.toString() });
+        if (remote.error || remote.err || remote.success === false) {
+            throw new Error(remote.error || remote.msg || 'Failed to get batch claim signature');
+        }
+        return remote;
+    }
+
+    // Burn several vaults in one tx via batchClaimWithSignedPrice. One wallet
+    // signature + one witness signature + summed supply-tier price for the batch.
+    async performBatchBurn(web3: any, tokenIds: string[], callback: any = null) {
+        if (callback) { callback('performing Batch Burn') }
+        const accounts = await web3.eth.getAccounts();
+        let handlerContract = await getHandlerContract(web3);
+
+        const claimSig = await this.requestLocalBatchClaimSignature(web3, tokenIds, callback);
+        const remote = await this.requestRemoteBatchClaimSignature(web3, tokenIds, claimSig, callback);
+
+        const price = remote._price;
+        const isEth = remote._payment === '0x0000000000000000000000000000000000000000';
+        const value = isEth ? price : '0';
+
+        const gasPrice = await web3.eth.getGasPrice();
+        let createdTxObject = handlerContract.methods.batchClaimWithSignedPrice(
+            remote._nftAddresses,
+            remote._tokenIds,
+            remote._payment,
+            price,
+            remote._nonce,
+            remote._signature
+        );
+        const gas = await createdTxObject.estimateGas({ from: accounts[0], value });
+
+        let burnResponse = await createdTxObject.send({ from: accounts[0], value, gasPrice, gas })
+        .on('transactionHash', (hash: any) => {
+            if (callback) callback(`Transaction submitted. Hash`, hash);
+        })
+        .on('confirmation', (confirmationNumber: any, receipt: any) => {
+            if (callback) callback(`Batch Burn Complete. Confirmation Number`, confirmationNumber);
+        })
+        .on('error', (error: { message: any; }) => {
+            if (callback) callback(`Transaction Error`, error.message);
+        });
+
+        if (callback) { callback('Batch Burn Complete') }
+        return burnResponse;
+    }
+
 
     async contentTypeReport(url: string) {
         return await checkContentType(url)
@@ -699,6 +785,18 @@ class EmblemVaultSDK {
         return performClaimEvm(this.getSdkContext(), client, tokenId, chainId as number, metadata, claimIdentifier, vaultIsV2, needsOnChainUnvault, callback);
     }
 
+    // Client-path batch claim: burn several vaults in one tx (Step 1 only). Reveal
+    // each vault's keys afterward with performClaimChainWithClient (skips Step 1).
+    async performBatchBurnWithClient(
+        client: EmblemVaultClient,
+        tokenIds: string[],
+        chainId: number | 'solana' = ETHEREUM_MAINNET_CHAIN_ID,
+        callback?: ProgressCallback
+    ): Promise<{ txHash: string }> {
+        getChainConfig(chainId);
+        return performBatchClaimEvm(this.getSdkContext(), client, tokenIds, chainId as number, callback);
+    }
+
     async deleteVaultWithClient(
         client: EmblemVaultClient,
         tokenId: string,

package/types/evm-operations.d.ts

@@ -2,3 +2,6 @@ import type { EmblemVaultClient, ProgressCallback, MintResult, ClaimResult, Meta
 export declare function performMintEvm(ctx: SdkContext, client: EmblemVaultClient, tokenId: string, chainId: number, callback?: ProgressCallback): Promise<MintResult>;
 export declare function performClaimEvm(ctx: SdkContext, client: EmblemVaultClient, tokenId: string, chainId: number, metadata: MetaData, claimIdentifier: string, vaultIsV2: boolean, needsOnChainUnvault: boolean, callback?: ProgressCallback): Promise<ClaimResult>;
 export declare function deleteVaultEvm(client: EmblemVaultClient, tokenId: string, chainId: number, callback?: ProgressCallback): Promise<boolean>;
+export declare function performBatchClaimEvm(ctx: SdkContext, client: EmblemVaultClient, tokenIds: string[], chainId: number, callback?: ProgressCallback): Promise<{
+    txHash: string;
+}>;

package/types/index.d.ts

@@ -52,6 +52,7 @@ declare class EmblemVaultSDK {
     requestLocalMintSignature(web3: any, tokenId: string, callback?: any): Promise<any>;
     requestLocalClaimSignature(web3: any, tokenId: string, serialNumber: any, callback?: any): Promise<any>;
     requestRemoteMintSignature(web3: any, tokenId: string, signature: string, callback?: any): Promise<any>;
+    requestRemoteClaimSignature(web3: any, tokenId: string, signature: string, callback?: any): Promise<any>;
     generateBulkMintMessage(tokenIds: string[]): string;
     isV2Contract(metadata: any, chainId: number): boolean;
     requestBulkMintSignature(request: BulkMintRequest, callback?: any): Promise<BulkMintResponse>;
@@ -64,6 +65,9 @@ declare class EmblemVaultSDK {
     getQuote(web3: any, amount: number, callback?: any): Promise<BigNumber>;
     performMint(web3: any, quote: any, remoteMintSig: any, callback?: any): Promise<any>;
     performBurn(web3: any, tokenId: any, callback?: any): Promise<any>;
+    requestLocalBatchClaimSignature(web3: any, tokenIds: string[], callback?: any): Promise<any>;
+    requestRemoteBatchClaimSignature(web3: any, tokenIds: string[], signature: string, callback?: any): Promise<any>;
+    performBatchBurn(web3: any, tokenIds: string[], callback?: any): Promise<any>;
     contentTypeReport(url: string): Promise<unknown>;
     legacyBalanceFromContractByAddress(web3: any, address: string): Promise<number[]>;
     refreshLegacyOwnership(web3: any, address: string): Promise<void>;
@@ -72,6 +76,9 @@ declare class EmblemVaultSDK {
     private getSdkContext;
     performMintChainWithClient(client: EmblemVaultClient, tokenId: string, chainId?: number | 'solana', callback?: ProgressCallback): Promise<MintResult>;
     performClaimChainWithClient(client: EmblemVaultClient, tokenId: string, chainId?: number | 'solana', callback?: ProgressCallback): Promise<ClaimResult>;
+    performBatchBurnWithClient(client: EmblemVaultClient, tokenIds: string[], chainId?: number | 'solana', callback?: ProgressCallback): Promise<{
+        txHash: string;
+    }>;
     deleteVaultWithClient(client: EmblemVaultClient, tokenId: string, chainId?: number | 'solana', callback?: ProgressCallback): Promise<boolean>;
     sweepVaultUsingPhrase(phrase: string, satsPerByte?: number, broadcast?: boolean): Promise<unknown>;
 }