four-flap-meme-sdk 1.3.93 → 1.3.94

package/dist/utils/erc20.d.ts

@@ -167,14 +167,6 @@ export type ApproveTokenBatchParams = {
     privateKeys: string[];
     tokenAddress: string;
     amounts: (bigint | 'max')[];
-    /** 是否只签名不提交（默认 false，直接发送交易） */
-    signOnly?: boolean;
-    /** Gas Price（可选，单位 Gwei，signOnly=true 时生效） */
-    gasPriceGwei?: number;
-    /** Gas Limit（可选，默认 100000，signOnly=true 时生效） */
-    gasLimit?: number;
-    /** 链ID（可选，默认56=BSC，signOnly=true 时生效） */
-    chainId?: number;
 };
 export type ApproveTokenBatchRawParams = {
     rpcUrl: string;
@@ -182,16 +174,7 @@ export type ApproveTokenBatchRawParams = {
     tokenAddress: string;
     spenderAddress: string;
     amounts: (bigint | 'max')[];
-    /** 是否只签名不提交（默认 false，直接发送交易） */
-    signOnly?: boolean;
-    /** Gas Price（可选，单位 Gwei，signOnly=true 时生效） */
-    gasPriceGwei?: number;
-    /** Gas Limit（可选，默认 100000，signOnly=true 时生效） */
-    gasLimit?: number;
-    /** 链ID（可选，默认56=BSC，signOnly=true 时生效） */
-    chainId?: number;
 };
-/** signOnly=false 时的返回结果（直接发送交易） */
 export type ApproveTokenBatchResult = {
     success: boolean;
     approvedCount: number;
@@ -204,107 +187,18 @@ export type ApproveTokenBatchResult = {
         error?: string;
     }>;
 };
-/** signOnly=true 时的返回结果（仅签名） */
-export type ApproveTokenBatchSignResult = {
-    /** 需要授权的签名交易数组（已过滤掉已授权的钱包） */
-    signedTransactions: string[];
-    /** 详细结果 */
-    results: Array<{
-        owner: string;
-        /** 是否已授权（无需发送交易） */
-        alreadyApproved: boolean;
-        currentAllowance: bigint;
-        requiredAllowance: bigint;
-        /** 签名交易（仅当 alreadyApproved=false 时有值） */
-        signedTx?: string;
-    }>;
-    /** 需要授权的钱包数量 */
-    needApproveCount: number;
-    /** 已授权的钱包数量 */
-    alreadyApprovedCount: number;
-};
 /**
  * ✅ 智能路由：批量授权 ERC20 代币（自动选择 spender，自动检查，只在不足时才发送交易）
  *
  * @param params - 批量授权参数
- * @param params.signOnly - 是否只签名不提交（默认 false）
- *   - false: 直接发送交易并等待确认，返回 ApproveTokenBatchResult
- *   - true: 只签名不提交，返回 ApproveTokenBatchSignResult，前端可通过 submitBundleToBlockRazor 提交
  * @returns 批量授权结果
- *
- * @example
- * ```typescript
- * // 模式1：直接发送交易（默认）
- * const result = await approveTokenBatch({
- *   chain: 'BSC',
- *   platform: 'four',
- *   rpcUrl: 'https://bsc-dataseed.binance.org',
- *   privateKeys: [key1, key2],
- *   tokenAddress: '0x...',
- *   amounts: ['max', 'max']
- * });
- *
- * // 模式2：只签名，前端提交
- * const signResult = await approveTokenBatch({
- *   chain: 'BSC',
- *   platform: 'four',
- *   rpcUrl: 'https://bsc-dataseed.binance.org',
- *   privateKeys: [key1, key2],
- *   tokenAddress: '0x...',
- *   amounts: ['max', 'max'],
- *   signOnly: true
- * });
- * // 提交到 BlockRazor
- * if (signResult.signedTransactions.length > 0) {
- *   await submitBundleToBlockRazor(signResult.signedTransactions, { blockOffset: 10 });
- * }
- * ```
  */
-export declare function approveTokenBatch(params: ApproveTokenBatchParams & {
-    signOnly: true;
-}): Promise<ApproveTokenBatchSignResult>;
-export declare function approveTokenBatch(params: ApproveTokenBatchParams & {
-    signOnly?: false;
-}): Promise<ApproveTokenBatchResult>;
+export declare function approveTokenBatch(params: ApproveTokenBatchParams): Promise<ApproveTokenBatchResult>;
 /**
  * ✅ 底层方法：批量授权 ERC20 代币（手动指定 spender）
  * 适用于任意 spender 地址（Flap、Four、PancakeSwap V2/V3 等）
  *
  * @param params - 批量授权参数
- * @param params.signOnly - 是否只签名不提交（默认 false）
- *   - false: 直接发送交易并等待确认，返回 ApproveTokenBatchResult
- *   - true: 只签名不提交，返回 ApproveTokenBatchSignResult，前端可通过 submitBundleToBlockRazor 提交
  * @returns 批量授权结果
- *
- * @example
- * ```typescript
- * // 模式1：直接发送交易（默认）
- * const result = await approveTokenBatchRaw({
- *   rpcUrl: 'https://bsc-dataseed.binance.org',
- *   privateKeys: [key1, key2],
- *   tokenAddress: '0x...',
- *   spenderAddress: '0x...',
- *   amounts: ['max', 'max']
- * });
- *
- * // 模式2：只签名，前端提交
- * const signResult = await approveTokenBatchRaw({
- *   rpcUrl: 'https://bsc-dataseed.binance.org',
- *   privateKeys: [key1, key2],
- *   tokenAddress: '0x...',
- *   spenderAddress: '0x...',
- *   amounts: ['max', 'max'],
- *   signOnly: true
- * });
- * // 提交到 BlockRazor
- * if (signResult.signedTransactions.length > 0) {
- *   await submitBundleToBlockRazor(signResult.signedTransactions, { blockOffset: 10 });
- * }
- * ```
  */
-export declare function approveTokenBatchRaw(params: ApproveTokenBatchRawParams & {
-    signOnly: true;
-}): Promise<ApproveTokenBatchSignResult>;
-export declare function approveTokenBatchRaw(params: ApproveTokenBatchRawParams & {
-    signOnly?: false;
-}): Promise<ApproveTokenBatchResult>;
+export declare function approveTokenBatchRaw(params: ApproveTokenBatchRawParams): Promise<ApproveTokenBatchResult>;

package/dist/utils/erc20.js

@@ -1,4 +1,4 @@
-import { Contract, Wallet, JsonRpcProvider, Interface, parseUnits } from 'ethers';
+import { Contract, Wallet, JsonRpcProvider } from 'ethers';
 import { ADDRESSES } from './constants.js';
 const ERC20_ABI = [
     { "constant": false, "inputs": [{ "name": "spender", "type": "address" }, { "name": "value", "type": "uint256" }], "name": "approve", "outputs": [{ "name": "", "type": "bool" }], "type": "function" },
@@ -482,13 +482,26 @@ export async function checkAllowanceBatchRaw(rpcUrl, tokenAddress, ownerAddresse
     await validateContractAddress(provider, normalizedSpender, 'Spender');
     return batchCheckAllowances(provider, normalizedToken, normalizedOwners, normalizedSpender);
 }
+/**
+ * ✅ 智能路由：批量授权 ERC20 代币（自动选择 spender，自动检查，只在不足时才发送交易）
+ *
+ * @param params - 批量授权参数
+ * @returns 批量授权结果
+ */
 export async function approveTokenBatch(params) {
-    const { chain, platform, rpcUrl, privateKeys, tokenAddress, amounts, signOnly, gasPriceGwei, gasLimit, chainId } = params;
+    const { chain, platform, rpcUrl, privateKeys, tokenAddress, amounts } = params;
     const spenderAddress = resolveSpenderAddress(chain, platform);
-    return approveTokenBatchRaw({ rpcUrl, privateKeys, tokenAddress, spenderAddress, amounts, signOnly, gasPriceGwei, gasLimit, chainId });
+    return approveTokenBatchRaw({ rpcUrl, privateKeys, tokenAddress, spenderAddress, amounts });
 }
+/**
+ * ✅ 底层方法：批量授权 ERC20 代币（手动指定 spender）
+ * 适用于任意 spender 地址（Flap、Four、PancakeSwap V2/V3 等）
+ *
+ * @param params - 批量授权参数
+ * @returns 批量授权结果
+ */
 export async function approveTokenBatchRaw(params) {
-    const { rpcUrl, privateKeys, tokenAddress, spenderAddress, amounts, signOnly, gasPriceGwei, gasLimit, chainId = 56 } = params;
+    const { rpcUrl, privateKeys, tokenAddress, spenderAddress, amounts } = params;
     if (privateKeys.length === 0 || amounts.length !== privateKeys.length) {
         throw new Error('❌ 私钥数量和授权数量必须匹配');
     }
@@ -505,67 +518,6 @@ export async function approveTokenBatchRaw(params) {
     const requiredAmounts = amounts.map(amount => amount === 'max'
         ? BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
         : amount);
-    // ==================== signOnly=true：只签名不提交 ====================
-    if (signOnly) {
-        // ✅ 并行获取：当前授权额度 + nonces + gasPrice
-        const [currentAllowances, nonces, fetchedGasPrice] = await Promise.all([
-            batchCheckAllowances(provider, normalizedToken, ownerAddresses, normalizedSpender),
-            Promise.all(wallets.map(w => provider.getTransactionCount(w.address, 'latest'))),
-            gasPriceGwei ? Promise.resolve(parseUnits(gasPriceGwei.toString(), 'gwei')) : provider.getFeeData().then(fee => fee.gasPrice || parseUnits('3', 'gwei'))
-        ]);
-        const finalGasPrice = fetchedGasPrice;
-        const finalGasLimit = BigInt(gasLimit || 100000);
-        // ✅ ERC20 approve 函数的 ABI 编码
-        const erc20Interface = new Interface(ERC20_ABI);
-        // ✅ 并行签名所有需要授权的交易
-        const signPromises = wallets.map(async (wallet, i) => {
-            const ownerAddress = ownerAddresses[i];
-            const currentAllowance = currentAllowances[i];
-            const requiredAmount = requiredAmounts[i];
-            // 如果已经授权足够，跳过
-            if (currentAllowance >= requiredAmount) {
-                return {
-                    owner: ownerAddress,
-                    alreadyApproved: true,
-                    currentAllowance,
-                    requiredAllowance: requiredAmount,
-                    signedTx: undefined
-                };
-            }
-            // 构建并签名交易
-            const txData = erc20Interface.encodeFunctionData('approve', [normalizedSpender, requiredAmount]);
-            const signedTx = await wallet.signTransaction({
-                to: normalizedToken,
-                data: txData,
-                nonce: nonces[i],
-                gasLimit: finalGasLimit,
-                gasPrice: finalGasPrice,
-                chainId,
-                type: 0 // Legacy 交易
-            });
-            return {
-                owner: ownerAddress,
-                alreadyApproved: false,
-                currentAllowance,
-                requiredAllowance: requiredAmount,
-                signedTx
-            };
-        });
-        const results = await Promise.all(signPromises);
-        // ✅ 提取所有签名交易（过滤掉已授权的）
-        const signedTransactions = results
-            .filter(r => !r.alreadyApproved && r.signedTx)
-            .map(r => r.signedTx);
-        const alreadyApprovedCount = results.filter(r => r.alreadyApproved).length;
-        const needApproveCount = results.filter(r => !r.alreadyApproved).length;
-        return {
-            signedTransactions,
-            results,
-            needApproveCount,
-            alreadyApprovedCount
-        };
-    }
-    // ==================== signOnly=false（默认）：直接发送交易 ====================
     // ✅ 优化：并行检查所有钱包的授权额度
     const currentAllowances = await batchCheckAllowances(provider, normalizedToken, ownerAddresses, normalizedSpender);
     // ✅ 优化：并行发送所有需要授权的交易

package/package.json

@@ -1,10 +1,24 @@
 {
   "name": "four-flap-meme-sdk",
-  "version": "1.3.93",
-  "description": "SDK for Flap bonding curve and four.meme TokenManager",
+  "version": "1.3.94",
+  "description": "SDK for Flap bonding curve, four.meme TokenManager, and Solana DEX",
   "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,32 @@
     "node": ">=18"
   },
   "dependencies": {
+    "@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.0",
+    "@pump-fun/pump-sdk": "^1.23.0",
+    "@pump-fun/pump-swap-sdk": "^1.11.0",
+    "@raydium-io/raydium-sdk-v2": "^0.2.30-alpha",
+    "@solana/spl-token": "^0.4.14",
+    "@solana/web3.js": "^1.98.4",
     "axios": "^1.12.2",
     "ethers": "^6.11.0",
-    "pinata": "^1.10.1"
+    "pinata": "^1.10.1",
+    "tweetnacl": "^1.0.3"
+  },
+  "optionalDependencies": {
+    "@orca-so/wavebreak": "^1.1.7"
   },
   "devDependencies": {
+    "@types/bn.js": "^5.2.0",
+    "@types/bs58": "^4.0.4",
     "typescript": "^5.6.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;
-    }
-}