emblem-vault-sdk 2.12.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/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.12.0';
+const SDK_VERSION = '2.13.0';
 class EmblemVaultSDK {
     constructor(apiKey, baseUrl, v3Url, sigUrl) {
         this.apiKey = apiKey;
@@ -604,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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emblem-vault-sdk",
-  "version": "2.12.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",
@@ -61,4 +64,4 @@
   "engines": {
     "node": ">=20.5.1"
   }
-}
+}

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 {

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';
@@ -526,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);

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/index.d.ts

@@ -62,6 +62,12 @@ 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>;