emblem-vault-sdk 2.11.0 → 2.13.0

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

@@ -14,7 +14,7 @@ import type {
     BulkMintResponse,
 } from './types';
 import { NFT_DATA, checkContentType, decryptKeys, fetchData, generateTemplate, genericGuard, getHandlerContract, getLegacyContract, getQuoteContractObject, getSatsConnectAddress, getTorusKeys, metadataAllProjects, metadataObj2Arr, signPSBT, templateGuard } from './utils';
-import { generateTaprootAddressFromMnemonic, getPsbtTxnSize } from './derive';
+import { generateTaprootAddressFromMnemonic, getPsbtTxnSize, deriveSolanaFromMnemonic } from './derive';
 import {
     ETHEREUM_MAINNET_CHAIN_ID,
 } from './constants';
@@ -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
@@ -512,6 +526,15 @@ class EmblemVaultSDK {
         return ukeys
     }
 
+    // Re-derive the Solana key from a claimed vault's decrypted mnemonic. Solana is
+    // ed25519 (not secp256k1), so it can't go through the bitcoinjs derivation the other
+    // coins use — this uses the SLIP-0010 ed25519 derivation in ./derive (matching the
+    // serverless creation-side byte-for-byte). Returns { address, secretKey (base58,
+    // Phantom-importable), path, coin:'SOL' }.
+    deriveSolanaKeys(phrase: string) {
+        return deriveSolanaFromMnemonic(phrase);
+    }
+
     async getQuote(web3: any, amount: number, callback: any = null) {
         if (callback) { callback('requesting Quote')}
         let quoteContract = await getQuoteContractObject(web3);
@@ -567,25 +590,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 +626,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 +794,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/derive.d.ts

@@ -1,3 +1,9 @@
+export declare const deriveSolanaFromMnemonic: (phrase: string) => {
+    address: string;
+    secretKey: string;
+    path: string;
+    coin: string;
+};
 declare global {
     interface Window {
         bitcoin: any;

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>;
@@ -61,9 +62,18 @@ declare class EmblemVaultSDK {
         privateKey: any;
     }>;
     decryptVaultKeys(tokenId: string, dkeys: any, callback?: any): Promise<any>;
+    deriveSolanaKeys(phrase: string): {
+        address: string;
+        secretKey: string;
+        path: string;
+        coin: string;
+    };
     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 +82,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>;
 }