@toon-protocol/sdk 0.4.0 → 0.5.0

package/dist/index.js

@@ -10,7 +10,10 @@ import { wordlist } from "@scure/bip39/wordlists/english.js";
 import { HDKey } from "@scure/bip32";
 import { getPublicKey } from "nostr-tools/pure";
 import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { ed25519 } from "@noble/curves/ed25519.js";
 import { keccak_256 } from "@noble/hashes/sha3.js";
+import { hmac } from "@noble/hashes/hmac.js";
+import { sha512 } from "@noble/hashes/sha512.js";
 import { bytesToHex } from "@noble/hashes/utils.js";
 
 // src/errors.ts
@@ -71,7 +74,9 @@ function fromMnemonic(mnemonic, options) {
       throw new IdentityError(`Failed to derive private key at path ${path}`);
     }
     const secretKey = hdKey.privateKey;
-    return deriveIdentity(secretKey);
+    const base = deriveIdentity(secretKey);
+    const solana = deriveSolanaIdentity(seed);
+    return { ...base, solana };
   } catch (error) {
     if (error instanceof IdentityError) {
       throw error;
@@ -140,6 +145,122 @@ function toChecksumAddress(addressHex) {
   }
   return checksummed;
 }
+function slip0010Derive(seed, path) {
+  const encoder = new TextEncoder();
+  let I = hmac(sha512, encoder.encode("ed25519 seed"), seed);
+  let key = I.slice(0, 32);
+  let chainCode = I.slice(32);
+  for (const index of path) {
+    const data = new Uint8Array(37);
+    data[0] = 0;
+    data.set(key, 1);
+    data[33] = index >>> 24 & 255;
+    data[34] = index >>> 16 & 255;
+    data[35] = index >>> 8 & 255;
+    data[36] = index & 255;
+    I = hmac(sha512, chainCode, data);
+    key = I.slice(0, 32);
+    chainCode = I.slice(32);
+  }
+  return key;
+}
+var SOLANA_PATH = [
+  2147483692,
+  // 44'
+  2147484149,
+  // 501'
+  2147483648,
+  // 0'
+  2147483648
+  // 0'
+];
+function deriveSolanaIdentity(seed) {
+  const privateKey = slip0010Derive(seed, SOLANA_PATH);
+  const publicKeyBytes = ed25519.getPublicKey(privateKey);
+  const keypair = new Uint8Array(64);
+  keypair.set(privateKey, 0);
+  keypair.set(publicKeyBytes, 32);
+  return { secretKey: keypair, publicKey: base58Encode(publicKeyBytes) };
+}
+async function deriveMinaIdentity(seed) {
+  const path = "m/44'/12586'/0'/0/0";
+  const hdKey = HDKey.fromMasterSeed(seed).derive(path);
+  if (!hdKey.privateKey) {
+    throw new IdentityError(`Failed to derive Mina private key at path ${path}`);
+  }
+  const keyBytes = new Uint8Array(hdKey.privateKey);
+  const hexKey = bytesToHex(keyBytes);
+  try {
+    const MinaSignerLib = await import("mina-signer");
+    const Client = "default" in MinaSignerLib ? MinaSignerLib.default : MinaSignerLib;
+    const client = new Client({ network: "mainnet" });
+    const publicKey = client.derivePublicKey(hexKey);
+    return { privateKey: hexKey, publicKey };
+  } catch {
+    return void 0;
+  }
+}
+async function fromMnemonicFull(mnemonic, options) {
+  const identity = fromMnemonic(mnemonic, options);
+  let seed;
+  try {
+    seed = mnemonicToSeedSync(mnemonic);
+    const mina = await deriveMinaIdentity(seed);
+    if (mina) {
+      return { ...identity, mina };
+    }
+  } finally {
+    if (seed) {
+      seed.fill(0);
+    }
+  }
+  return identity;
+}
+function generateSolanaKeypair() {
+  const privateKey = ed25519.utils.randomSecretKey();
+  const publicKeyBytes = ed25519.getPublicKey(privateKey);
+  const keypair = new Uint8Array(64);
+  keypair.set(privateKey, 0);
+  keypair.set(publicKeyBytes, 32);
+  return { secretKey: keypair, publicKey: base58Encode(publicKeyBytes) };
+}
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Encode(bytes) {
+  let zeros = 0;
+  for (let i = 0; i < bytes.length && bytes[i] === 0; i++) zeros++;
+  let value = 0n;
+  for (const byte of bytes) {
+    value = value * 256n + BigInt(byte);
+  }
+  let result = "";
+  while (value > 0n) {
+    result = BASE58_ALPHABET[Number(value % 58n)] + result;
+    value = value / 58n;
+  }
+  for (let i = 0; i < zeros; i++) {
+    result = "1" + result;
+  }
+  return result || "1";
+}
+function base58Decode(str) {
+  let zeros = 0;
+  for (let i = 0; i < str.length && str[i] === "1"; i++) zeros++;
+  let value = 0n;
+  for (const ch of str) {
+    const idx = BASE58_ALPHABET.indexOf(ch);
+    if (idx === -1) throw new IdentityError(`Invalid base58 character: ${ch}`);
+    value = value * 58n + BigInt(idx);
+  }
+  const hex = value === 0n ? "" : value.toString(16);
+  const hexPadded = hex.length % 2 ? "0" + hex : hex;
+  const rawBytes = [];
+  for (let i = 0; i < hexPadded.length; i += 2) {
+    rawBytes.push(parseInt(hexPadded.slice(i, i + 2), 16));
+  }
+  const result = new Uint8Array(zeros + rawBytes.length);
+  result.set(rawBytes, zeros);
+  return result;
+}
 
 // src/handler-context.ts
 function createHandlerContext(options) {
@@ -2073,6 +2194,8 @@ export {
   TurboUploadAdapter,
   VerificationError,
   WorkflowOrchestrator,
+  base58Decode,
+  base58Encode,
   buildSkillDescriptor,
   createArweaveDvmHandler,
   createEventStorageHandler,
@@ -2083,8 +2206,10 @@ export {
   createPricingValidator,
   createVerificationPipeline,
   fromMnemonic,
+  fromMnemonicFull,
   fromSecretKey,
   generateMnemonic,
+  generateSolanaKeypair,
   uploadBlob,
   uploadBlobChunked
 };