emblem-vault-sdk 2.11.0 → 2.13.0

package/dist/derive.js

@@ -42,12 +42,62 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPsbtTxnSize = exports.generateTaprootAddressFromMnemonic = void 0;
+exports.getPsbtTxnSize = exports.generateTaprootAddressFromMnemonic = exports.deriveSolanaFromMnemonic = void 0;
 const bip32_1 = require("bip32");
 const bip39 = __importStar(require("bip39"));
 // import bitcoin from "bitcoinjs-lib";
 const ecc = __importStar(require("@bitcoin-js/tiny-secp256k1-asmjs"));
+const hmac_1 = require("@noble/hashes/hmac");
+const sha512_1 = require("@noble/hashes/sha512");
+const ed25519_1 = require("@noble/curves/ed25519");
+// bs58@4 ships no type declarations; require it (CJS) to avoid TS7016.
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const bs58 = require("bs58");
 const bip32 = (0, bip32_1.BIP32Factory)(ecc);
+// --- Solana (ed25519 SLIP-0010) HD derivation ---
+// Solana uses ed25519, NOT secp256k1, so bip32/bitcoinjs can't derive it. We do the
+// SLIP-0010 ed25519 derivation via @noble (browser-safe, already a dependency; NOT
+// @solana/web3.js — that heavy dep is the conflict that got SOL derivation disabled).
+// Path m/44'/501'/0'/0' (all hardened) is the Phantom/Solflare standard. This matches
+// the serverless vault-creation derivation byte-for-byte, so a claimed vault's SOL key
+// re-derives to the stored address.
+const SOLANA_PATH = "m/44'/501'/0'/0'";
+function slip10DeriveEd25519Seed(pathStr, seed) {
+    let I = (0, hmac_1.hmac)(sha512_1.sha512, new TextEncoder().encode("ed25519 seed"), seed);
+    let key = I.slice(0, 32);
+    let chain = I.slice(32);
+    for (const seg of pathStr.split("/").slice(1)) {
+        const idx = ((parseInt(seg, 10) | 0x80000000) >>> 0); // all segments hardened
+        const data = new Uint8Array(1 + 32 + 4);
+        data[0] = 0;
+        data.set(key, 1);
+        data[33] = (idx >>> 24) & 255;
+        data[34] = (idx >>> 16) & 255;
+        data[35] = (idx >>> 8) & 255;
+        data[36] = idx & 255;
+        I = (0, hmac_1.hmac)(sha512_1.sha512, chain, data);
+        key = I.slice(0, 32);
+        chain = I.slice(32);
+    }
+    return key; // 32-byte ed25519 seed
+}
+// Derive the Solana address + Phantom-importable secret key from a vault mnemonic.
+// Returns { address (base58 pubkey), secretKey (base58 of the 64-byte secret), path, coin }.
+const deriveSolanaFromMnemonic = (phrase) => {
+    const seed = bip39.mnemonicToSeedSync(phrase);
+    const priv = slip10DeriveEd25519Seed(SOLANA_PATH, new Uint8Array(seed));
+    const pub = ed25519_1.ed25519.getPublicKey(priv);
+    const secret = new Uint8Array(64);
+    secret.set(priv, 0);
+    secret.set(pub, 32);
+    return {
+        address: bs58.encode(pub),
+        secretKey: bs58.encode(secret), // 64-byte secret, base58 — import into Phantom/Solflare
+        path: SOLANA_PATH,
+        coin: "SOL",
+    };
+};
+exports.deriveSolanaFromMnemonic = deriveSolanaFromMnemonic;
 const generateTaprootAddressFromMnemonic = (phrase) => __awaiter(void 0, void 0, void 0, function* () {
     let bitcoin = window.bitcoin;
     let mainnet = bitcoin.networks.mainnet;

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.13.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
@@ -585,6 +604,14 @@ 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) {
+        return (0, derive_1.deriveSolanaFromMnemonic)(phrase);
+    }
     getQuote(web3_1, amount_1) {
         return __awaiter(this, arguments, void 0, function* (web3, amount, callback = null) {
             if (callback) {
@@ -639,24 +666,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 +702,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 +861,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.13.0",
   "description": "Emblem Vault Software Development Kit",
   "main": "dist/index.js",
   "files": [
@@ -41,12 +41,15 @@
   "dependencies": {
     "@bitcoin-js/tiny-secp256k1-asmjs": "^2.2.3",
     "@ethersproject/bignumber": "^5.7.0",
+    "@noble/curves": "^1.4.2",
+    "@noble/hashes": "^1.4.0",
     "@toruslabs/fetch-node-details": "^8.0.0",
     "@toruslabs/torus.js": "^6.2.0",
     "bchaddrjs": "^0.5.2",
     "bip32": "^4.0.0",
     "bip39": "^3.1.0",
     "bitcoinjs-lib": "^6.1.5",
+    "bs58": "^4.0.1",
     "bitcore-mnemonic": "^10.0.23",
     "crypto-js": "^4.2.0",
     "ethereumjs-util": "^7.1.5",

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/derive.ts

@@ -3,9 +3,61 @@ import * as bip39 from "bip39";
 // import bitcoin from "bitcoinjs-lib";
 
 import * as ecc from '@bitcoin-js/tiny-secp256k1-asmjs'
+import { hmac } from "@noble/hashes/hmac";
+import { sha512 } from "@noble/hashes/sha512";
+import { ed25519 } from "@noble/curves/ed25519";
+// bs58@4 ships no type declarations; require it (CJS) to avoid TS7016.
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const bs58: { encode: (b: Uint8Array) => string; decode: (s: string) => Uint8Array } = require("bs58");
 
 const bip32 = BIP32Factory(ecc);
 
+// --- Solana (ed25519 SLIP-0010) HD derivation ---
+// Solana uses ed25519, NOT secp256k1, so bip32/bitcoinjs can't derive it. We do the
+// SLIP-0010 ed25519 derivation via @noble (browser-safe, already a dependency; NOT
+// @solana/web3.js — that heavy dep is the conflict that got SOL derivation disabled).
+// Path m/44'/501'/0'/0' (all hardened) is the Phantom/Solflare standard. This matches
+// the serverless vault-creation derivation byte-for-byte, so a claimed vault's SOL key
+// re-derives to the stored address.
+const SOLANA_PATH = "m/44'/501'/0'/0'";
+
+function slip10DeriveEd25519Seed(pathStr: string, seed: Uint8Array): Uint8Array {
+  let I = hmac(sha512, new TextEncoder().encode("ed25519 seed"), seed);
+  let key = I.slice(0, 32);
+  let chain = I.slice(32);
+  for (const seg of pathStr.split("/").slice(1)) {
+    const idx = ((parseInt(seg, 10) | 0x80000000) >>> 0); // all segments hardened
+    const data = new Uint8Array(1 + 32 + 4);
+    data[0] = 0;
+    data.set(key, 1);
+    data[33] = (idx >>> 24) & 255;
+    data[34] = (idx >>> 16) & 255;
+    data[35] = (idx >>> 8) & 255;
+    data[36] = idx & 255;
+    I = hmac(sha512, chain, data);
+    key = I.slice(0, 32);
+    chain = I.slice(32);
+  }
+  return key; // 32-byte ed25519 seed
+}
+
+// Derive the Solana address + Phantom-importable secret key from a vault mnemonic.
+// Returns { address (base58 pubkey), secretKey (base58 of the 64-byte secret), path, coin }.
+export const deriveSolanaFromMnemonic = (phrase: string) => {
+  const seed = bip39.mnemonicToSeedSync(phrase);
+  const priv = slip10DeriveEd25519Seed(SOLANA_PATH, new Uint8Array(seed));
+  const pub = ed25519.getPublicKey(priv);
+  const secret = new Uint8Array(64);
+  secret.set(priv, 0);
+  secret.set(pub, 32);
+  return {
+    address: bs58.encode(pub),
+    secretKey: bs58.encode(secret), // 64-byte secret, base58 — import into Phantom/Solflare
+    path: SOLANA_PATH,
+    coin: "SOL",
+  };
+};
+
 // let mainnet: any = {"messagePrefix":"\u0018Bitcoin Signed Message:\n","bech32":"bc","bip32":{"public":76067358,"private":76066276},"pubKeyHash":0,"scriptHash":5,"wif":128}
 declare global {
     interface Window {