four-flap-meme-sdk 1.5.5 → 1.5.6

package/dist/sol/utils/wallet.js

@@ -0,0 +1,210 @@
+/**
+ * Solana 钱包工具
+ * @module sol/utils/wallet
+ */
+import { Keypair, PublicKey } from '@solana/web3.js';
+import bs58 from 'bs58';
+/**
+ * 生成新的 Solana 钱包
+ * @returns 钱包信息
+ */
+export function generateKeypair() {
+    const keypair = Keypair.generate();
+    return {
+        publicKey: keypair.publicKey.toBase58(),
+        secretKey: keypair.secretKey,
+        secretKeyBase58: bs58.encode(keypair.secretKey),
+        address: keypair.publicKey.toBase58(),
+    };
+}
+/**
+ * 批量生成钱包
+ * @param count 数量
+ * @returns 钱包列表
+ */
+export function generateKeypairs(count) {
+    const wallets = [];
+    for (let i = 0; i < count; i++) {
+        wallets.push(generateKeypair());
+    }
+    return wallets;
+}
+/**
+ * 批量生成钱包（增强版，返回更多信息）
+ * @param count 数量
+ * @returns 详细结果
+ */
+export function batchGenerateWallets(count) {
+    const wallets = [];
+    const addresses = [];
+    const secretKeys = [];
+    const keypairs = [];
+    for (let i = 0; i < count; i++) {
+        const keypair = Keypair.generate();
+        const address = keypair.publicKey.toBase58();
+        const secretKeyBase58 = bs58.encode(keypair.secretKey);
+        wallets.push({
+            publicKey: address,
+            secretKey: keypair.secretKey,
+            secretKeyBase58,
+            address,
+        });
+        addresses.push(address);
+        secretKeys.push(secretKeyBase58);
+        keypairs.push(keypair);
+    }
+    return {
+        wallets,
+        count,
+        addresses,
+        secretKeys,
+        keypairs,
+    };
+}
+/**
+ * 从私钥列表批量导入钱包
+ * @param secretKeys 私钥列表（base58 字符串）
+ * @returns 导入结果
+ */
+export function batchImportWallets(secretKeys) {
+    const keypairs = [];
+    const addresses = [];
+    const failed = [];
+    for (let i = 0; i < secretKeys.length; i++) {
+        try {
+            const keypair = keypairFromSecretKey(secretKeys[i]);
+            keypairs.push(keypair);
+            addresses.push(keypair.publicKey.toBase58());
+        }
+        catch (error) {
+            failed.push({
+                index: i,
+                secretKey: secretKeys[i].slice(0, 8) + '...', // 只显示前8位
+                error: error.message,
+            });
+        }
+    }
+    return {
+        keypairs,
+        addresses,
+        failed,
+    };
+}
+/**
+ * 从私钥导入钱包
+ * @param secretKey 私钥（Uint8Array 或 base58 字符串）
+ * @returns Keypair
+ */
+export function keypairFromSecretKey(secretKey) {
+    try {
+        let keyArray;
+        if (typeof secretKey === 'string') {
+            // base58 格式
+            keyArray = bs58.decode(secretKey);
+        }
+        else {
+            keyArray = secretKey;
+        }
+        // 验证私钥长度
+        if (keyArray.length !== 64) {
+            throw new Error(`Invalid secret key length: ${keyArray.length}, expected 64`);
+        }
+        return Keypair.fromSecretKey(keyArray);
+    }
+    catch (error) {
+        throw new Error(`Failed to import keypair: ${error.message}`);
+    }
+}
+/**
+ * 导出私钥为 base58 格式
+ * @param keypair Keypair
+ * @returns base58 编码的私钥
+ */
+export function exportSecretKey(keypair) {
+    return bs58.encode(keypair.secretKey);
+}
+/**
+ * 导出私钥为 Uint8Array
+ * @param keypair Keypair
+ * @returns Uint8Array 私钥
+ */
+export function exportSecretKeyArray(keypair) {
+    return keypair.secretKey;
+}
+/**
+ * 验证 Solana 地址格式
+ * @param address 地址字符串
+ * @returns 是否有效
+ */
+export function isValidAddress(address) {
+    try {
+        new PublicKey(address);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 验证私钥格式
+ * @param secretKey 私钥（base58 字符串）
+ * @returns 是否有效
+ */
+export function isValidSecretKey(secretKey) {
+    try {
+        const decoded = bs58.decode(secretKey);
+        return decoded.length === 64;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 从私钥获取公钥/地址
+ * @param secretKey 私钥（Uint8Array 或 base58 字符串）
+ * @returns 公钥地址
+ */
+export function getAddressFromSecretKey(secretKey) {
+    const keypair = keypairFromSecretKey(secretKey);
+    return keypair.publicKey.toBase58();
+}
+/**
+ * 创建 PublicKey 对象
+ * @param address 地址字符串
+ * @returns PublicKey
+ */
+export function toPublicKey(address) {
+    if (!isValidAddress(address)) {
+        throw new Error(`Invalid Solana address: ${address}`);
+    }
+    return new PublicKey(address);
+}
+/**
+ * 比较两个地址是否相同
+ * @param addr1 地址1
+ * @param addr2 地址2
+ * @returns 是否相同
+ */
+export function isSameAddress(addr1, addr2) {
+    try {
+        const pk1 = new PublicKey(addr1);
+        const pk2 = new PublicKey(addr2);
+        return pk1.equals(pk2);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 缩短地址显示
+ * @param address 完整地址
+ * @param prefixLength 前缀长度（默认4）
+ * @param suffixLength 后缀长度（默认4）
+ * @returns 缩短后的地址
+ */
+export function shortenAddress(address, prefixLength = 4, suffixLength = 4) {
+    if (address.length <= prefixLength + suffixLength + 3) {
+        return address;
+    }
+    return `${address.slice(0, prefixLength)}...${address.slice(-suffixLength)}`;
+}

package/package.json

@@ -1,10 +1,24 @@
 {
   "name": "four-flap-meme-sdk",
-  "version": "1.5.5",
+  "version": "1.5.6",
   "description": "SDK for Flap bonding curve and four.meme TokenManager",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./sol": {
+      "types": "./dist/sol/index.d.ts",
+      "import": "./dist/sol/index.js"
+    },
+    "./sol/*": {
+      "types": "./dist/sol/*.d.ts",
+      "import": "./dist/sol/*.js"
+    }
+  },
   "files": [
     "dist",
     "src/abis/*.json"
@@ -29,11 +43,33 @@
     "node": ">=18"
   },
   "dependencies": {
-    "axios": "^1.12.2",
-    "ethers": "^6.11.0",
-    "pinata": "^1.10.1"
+    "@metaplex-foundation/mpl-token-metadata": "^3.4.0",
+    "@metaplex-foundation/umi": "^1.4.1",
+    "@metaplex-foundation/umi-bundle-defaults": "^1.4.1",
+    "@metaplex-foundation/umi-web3js-adapters": "^1.4.1",
+    "@meteora-ag/cp-amm-sdk": "^1.2.6",
+    "@meteora-ag/dlmm": "^1.9.0",
+    "@meteora-ag/dynamic-amm-sdk": "^1.4.1",
+    "@meteora-ag/dynamic-bonding-curve-sdk": "^1.4.9",
+    "@orca-so/common-sdk": "^0.7.0",
+    "@orca-so/whirlpools-sdk": "^0.17.4",
+    "@pump-fun/pump-sdk": "^1.24.0",
+    "@pump-fun/pump-swap-sdk": "^1.11.0",
+    "@raydium-io/raydium-sdk-v2": "^0.2.31-alpha",
+    "@solana/spl-token": "^0.4.14",
+    "@solana/web3.js": "^1.98.4",
+    "axios": "^1.13.2",
+    "ethers": "^6.16.0",
+    "pinata": "^2.5.1",
+    "tweetnacl": "^1.0.3"
+  },
+  "optionalDependencies": {
+    "@orca-so/wavebreak": "^1.1.7"
   },
   "devDependencies": {
-    "typescript": "^5.6.3"
+    "@types/bn.js": "^5.2.0",
+    "@types/bs58": "^4.0.4",
+    "decimal.js": "^10.6.0",
+    "typescript": "^5.9.3"
   }
 }

package/dist/flap/portal-bundle-merkle/encryption.d.ts

@@ -1,16 +0,0 @@
-/**
- * ECDH + AES-GCM 加密工具（浏览器兼容）
- * 用于将签名交易用服务器公钥加密
- */
-/**
- * 用服务器公钥加密签名交易（ECDH + AES-GCM）
- *
- * @param signedTransactions 签名后的交易数组
- * @param publicKeyBase64 服务器提供的公钥（Base64 格式）
- * @returns JSON 字符串 {e: 临时公钥, i: IV, d: 密文}
- */
-export declare function encryptWithPublicKey(signedTransactions: string[], publicKeyBase64: string): Promise<string>;
-/**
- * 验证公钥格式（Base64）
- */
-export declare function validatePublicKey(publicKeyBase64: string): boolean;

package/dist/flap/portal-bundle-merkle/encryption.js

@@ -1,146 +0,0 @@
-/**
- * ECDH + AES-GCM 加密工具（浏览器兼容）
- * 用于将签名交易用服务器公钥加密
- */
-/**
- * 获取全局 crypto 对象（最简单直接的方式）
- */
-function getCryptoAPI() {
-    // 尝试所有可能的全局对象，优先浏览器环境
-    const cryptoObj = (typeof window !== 'undefined' && window.crypto) ||
-        (typeof self !== 'undefined' && self.crypto) ||
-        (typeof global !== 'undefined' && global.crypto) ||
-        (typeof globalThis !== 'undefined' && globalThis.crypto);
-    if (!cryptoObj) {
-        const env = typeof window !== 'undefined' ? 'Browser' : 'Node.js';
-        const protocol = typeof location !== 'undefined' ? location.protocol : 'unknown';
-        throw new Error(`❌ Crypto API 不可用。环境: ${env}, 协议: ${protocol}. ` +
-            '请确保在 HTTPS 或 localhost 下运行');
-    }
-    return cryptoObj;
-}
-/**
- * 获取 SubtleCrypto（用于加密操作）
- */
-function getSubtleCrypto() {
-    const crypto = getCryptoAPI();
-    if (!crypto.subtle) {
-        const protocol = typeof location !== 'undefined' ? location.protocol : 'unknown';
-        const hostname = typeof location !== 'undefined' ? location.hostname : 'unknown';
-        throw new Error(`❌ SubtleCrypto API 不可用。协议: ${protocol}, 主机: ${hostname}. ` +
-            '请确保：1) 使用 HTTPS (或 localhost)；2) 浏览器支持 Web Crypto API；' +
-            '3) 不在无痕/隐私浏览模式下');
-    }
-    return crypto.subtle;
-}
-/**
- * Base64 转 ArrayBuffer（优先使用浏览器 API）
- */
-function base64ToArrayBuffer(base64) {
-    // 浏览器环境（优先）
-    if (typeof atob !== 'undefined') {
-        const binaryString = atob(base64);
-        const bytes = new Uint8Array(binaryString.length);
-        for (let i = 0; i < binaryString.length; i++) {
-            bytes[i] = binaryString.charCodeAt(i);
-        }
-        return bytes.buffer;
-    }
-    // Node.js 环境（fallback）
-    if (typeof Buffer !== 'undefined') {
-        return Buffer.from(base64, 'base64').buffer;
-    }
-    throw new Error('❌ Base64 解码不可用');
-}
-/**
- * ArrayBuffer 转 Base64（优先使用浏览器 API）
- */
-function arrayBufferToBase64(buffer) {
-    // 浏览器环境（优先）
-    if (typeof btoa !== 'undefined') {
-        const bytes = new Uint8Array(buffer);
-        let binary = '';
-        for (let i = 0; i < bytes.length; i++) {
-            binary += String.fromCharCode(bytes[i]);
-        }
-        return btoa(binary);
-    }
-    // Node.js 环境（fallback）
-    if (typeof Buffer !== 'undefined') {
-        return Buffer.from(buffer).toString('base64');
-    }
-    throw new Error('❌ Base64 编码不可用');
-}
-/**
- * 生成随机 Hex 字符串
- */
-function randomHex(length) {
-    const crypto = getCryptoAPI();
-    const array = new Uint8Array(length);
-    crypto.getRandomValues(array);
-    return Array.from(array)
-        .map(b => b.toString(16).padStart(2, '0'))
-        .join('');
-}
-/**
- * 用服务器公钥加密签名交易（ECDH + AES-GCM）
- *
- * @param signedTransactions 签名后的交易数组
- * @param publicKeyBase64 服务器提供的公钥（Base64 格式）
- * @returns JSON 字符串 {e: 临时公钥, i: IV, d: 密文}
- */
-export async function encryptWithPublicKey(signedTransactions, publicKeyBase64) {
-    try {
-        // 0. 获取 SubtleCrypto 和 Crypto API
-        const subtle = getSubtleCrypto();
-        const crypto = getCryptoAPI();
-        // 1. 准备数据
-        const payload = {
-            signedTransactions,
-            timestamp: Date.now(),
-            nonce: randomHex(8)
-        };
-        const plaintext = JSON.stringify(payload);
-        // 2. 生成临时 ECDH 密钥对
-        const ephemeralKeyPair = await subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveKey']);
-        // 3. 导入服务器公钥
-        const publicKeyBuffer = base64ToArrayBuffer(publicKeyBase64);
-        const publicKey = await subtle.importKey('raw', publicKeyBuffer, { name: 'ECDH', namedCurve: 'P-256' }, false, []);
-        // 4. 派生共享密钥（AES-256）
-        const sharedKey = await subtle.deriveKey({ name: 'ECDH', public: publicKey }, ephemeralKeyPair.privateKey, { name: 'AES-GCM', length: 256 }, false, ['encrypt']);
-        // 5. AES-GCM 加密
-        const iv = crypto.getRandomValues(new Uint8Array(12));
-        const encrypted = await subtle.encrypt({ name: 'AES-GCM', iv }, sharedKey, new TextEncoder().encode(plaintext));
-        // 6. 导出临时公钥
-        const ephemeralPublicKeyRaw = await subtle.exportKey('raw', ephemeralKeyPair.publicKey);
-        // 7. 返回加密包（JSON 格式）
-        return JSON.stringify({
-            e: arrayBufferToBase64(ephemeralPublicKeyRaw), // 临时公钥
-            i: arrayBufferToBase64(iv.buffer), // IV
-            d: arrayBufferToBase64(encrypted) // 密文
-        });
-    }
-    catch (error) {
-        throw new Error(`加密失败: ${error?.message || String(error)}`);
-    }
-}
-/**
- * 验证公钥格式（Base64）
- */
-export function validatePublicKey(publicKeyBase64) {
-    try {
-        if (!publicKeyBase64)
-            return false;
-        // Base64 字符集验证
-        if (!/^[A-Za-z0-9+/=]+$/.test(publicKeyBase64))
-            return false;
-        // ECDH P-256 公钥固定长度 65 字节（未压缩）
-        // Base64 编码后约 88 字符
-        if (publicKeyBase64.length < 80 || publicKeyBase64.length > 100)
-            return false;
-        return true;
-    }
-    catch {
-        return false;
-    }
-}