four-flap-meme-sdk 2.2.19 → 3.0.0

package/dist/chains/xlayer/eip7702/transfer-context-helpers.js

@@ -0,0 +1,58 @@
+import { ethers } from 'ethers';
+import { getCachedProvider, createWallet, generateRandomWallets, getProfitRecipient } from './utils.js';
+import { UNIFIED_DELEGATE_ADDRESS, UNIFIED_DELEGATE_ABI } from './constants.js';
+export function createEip7702DelegateContext(config) {
+    const provider = getCachedProvider(config?.rpcUrl);
+    const delegateAddress = (config?.delegateAddress && config.delegateAddress.trim()) || UNIFIED_DELEGATE_ADDRESS;
+    const delegateInterface = new ethers.Interface(UNIFIED_DELEGATE_ABI);
+    const profitRecipient = getProfitRecipient(config);
+    return { provider, delegateAddress, delegateInterface, profitRecipient };
+}
+export function isNativeTransferToken(tokenAddress) {
+    return !tokenAddress;
+}
+export function generateHopWalletMatrix(rowCount, hopCount, provider) {
+    const allHopWalletInfos = [];
+    const allHopWallets = [];
+    for (let i = 0; i < rowCount; i++) {
+        if (hopCount > 0) {
+            const hopInfos = generateRandomWallets(hopCount);
+            allHopWalletInfos.push(hopInfos);
+            allHopWallets.push(hopInfos.map((info) => createWallet(info.privateKey, provider)));
+        }
+        else {
+            allHopWalletInfos.push([]);
+            allHopWallets.push([]);
+        }
+    }
+    return { allHopWalletInfos, allHopWallets };
+}
+export function resolveDispersePayerWallets(mainPrivateKey, payerPrivateKey, provider) {
+    const mainWallet = createWallet(mainPrivateKey, provider);
+    const hasSeparatePayer = Boolean(payerPrivateKey && payerPrivateKey !== mainPrivateKey);
+    const payerWallet = hasSeparatePayer && payerPrivateKey ? createWallet(payerPrivateKey, provider) : null;
+    const txSender = payerWallet ?? mainWallet;
+    return { mainWallet, payerWallet, txSender, hasSeparatePayer };
+}
+export function resolveListPayerWallet(ownerPrivateKeys, payerPrivateKey, provider, fallbackToFirst = true) {
+    const hasSeparatePayer = Boolean(payerPrivateKey && !ownerPrivateKeys.includes(payerPrivateKey));
+    const payerWallet = hasSeparatePayer && payerPrivateKey ? createWallet(payerPrivateKey, provider) : null;
+    const firstOwnerKey = ownerPrivateKeys[0];
+    const mainWallet = payerWallet ?? (fallbackToFirst && firstOwnerKey ? createWallet(firstOwnerKey, provider) : null);
+    return { payerWallet, hasSeparatePayer, mainWallet };
+}
+export function parseTransferAmountsWei(amounts, isNative, tokenDecimals) {
+    return amounts.map((amt) => (isNative ? ethers.parseEther(amt) : ethers.parseUnits(amt, tokenDecimals)));
+}
+export function normalizePairwiseAmounts(pairCount, amount, amounts) {
+    if (amounts && amounts.length > 0) {
+        if (amounts.length !== pairCount) {
+            throw new Error(`amounts 长度 (${amounts.length}) 必须与对数 (${pairCount}) 相同`);
+        }
+        return amounts;
+    }
+    if (amount !== undefined && amount.trim().length > 0) {
+        return new Array(pairCount).fill(amount);
+    }
+    throw new Error('必须提供 amount 或 amounts');
+}

package/dist/chains/xlayer/eip7702/types.d.ts

@@ -53,6 +53,8 @@ export interface BundleBuyParams {
     routerAddress?: string;
     /** V3 费率（可选，默认 2500，仅 V3 使用） */
     fee?: number;
+    /** 用户类型（影响利润率） */
+    userType?: UserType;
     /** 配置 */
     config?: EIP7702Config;
 }
@@ -87,6 +89,8 @@ export interface BundleSellParams {
     routerAddress?: string;
     /** V3 费率（可选，默认 2500，仅 V3 使用） */
     fee?: number;
+    /** 用户类型（影响利润率） */
+    userType?: UserType;
     /** 配置 */
     config?: EIP7702Config;
 }
@@ -156,6 +160,14 @@ export interface BundleSwapParams {
     routerAddress?: string;
     /** V3 费率（可选，默认 2500，仅 V3 使用） */
     fee?: number;
+    /** 用户类型（影响利润率） */
+    userType?: UserType;
+    /**
+     * 是否使用资金利用率模式（默认 false）
+     * - false（普通模式）: 卖家卖出 OKB 留在卖家账户，买家用自己预存的 OKB 买入
+     * - true（资金利用率模式）: 卖家卖出的 OKB 通过多跳转账给买家，买家用收到的 OKB 买入
+     */
+    useFundUtilization?: boolean;
     /** 配置 */
     config?: EIP7702Config;
 }
@@ -180,6 +192,14 @@ export interface BundleBatchSwapParams {
     routerAddress?: string;
     /** V3 费率（可选，默认 2500，仅 V3 使用） */
     fee?: number;
+    /** 用户类型（影响利润率） */
+    userType?: UserType;
+    /**
+     * 是否使用资金利用率模式（默认 false）
+     * - false（普通模式）: 卖家卖出 OKB 留在卖家账户，买家用自己预存的 OKB 买入
+     * - true（资金利用率模式）: 卖家卖出的 OKB 通过多跳转账给买家，买家用收到的 OKB 买入
+     */
+    useFundUtilization?: boolean;
     /** 配置 */
     config?: EIP7702Config;
 }
@@ -442,6 +462,74 @@ export interface BundleCreateToDexResult {
         profitAmount: string;
     };
 }
+export interface BundleMultiSwapParams {
+    /** Payer 钱包私钥（支付 Gas 费） */
+    mainPrivateKey: string;
+    /** 卖出钱包私钥列表 */
+    sellerPrivateKeys: string[];
+    /** 买入钱包私钥列表 */
+    buyerPrivateKeys: string[];
+    /** 买入总金额 (OKB) */
+    totalBuyAmount: string;
+    /** 代币地址 */
+    tokenAddress: string;
+    /** 代币精度 */
+    tokenDecimals?: number;
+    /** 卖出百分比（1-100，默认 100） */
+    sellPercent?: number;
+    /** 交易类型：FLAP 内盘 / V2 / V3（默认 V3） */
+    tradeType?: TradeType;
+    /** 路由地址（可选，根据 tradeType 自动选择） */
+    routerAddress?: string;
+    /** V3 费率（可选，默认 2500，仅 V3 使用） */
+    fee?: number;
+    /** 用户类型（影响利润率） */
+    userType?: UserType;
+    /** 配置 */
+    config?: EIP7702Config;
+}
+export interface BundleMultiSwapResult {
+    /** 签名后的交易 */
+    signedTransaction: string;
+    /** 元数据 */
+    metadata: {
+        payerAddress: string;
+        sellerAddresses: string[];
+        buyerAddresses: string[];
+        sellerCount: number;
+        buyerCount: number;
+        totalBuyAmount: string;
+        totalSellAmount: string;
+        profitAmount: string;
+        profitRecipient: string;
+        userType: string;
+    };
+}
+export interface BundleApproveMultiSpendersParams {
+    /** 主钱包（发起交易，支付 gas） */
+    mainPrivateKey: string;
+    /** 需要授权的钱包私钥列表 */
+    privateKeys: string[];
+    /** 代币地址 */
+    tokenAddress: string;
+    /** 授权给的地址列表（多个 spender） */
+    spenderAddresses: string[];
+    /** 授权金额（可选，默认 MaxUint256） */
+    amount?: bigint;
+    /** 配置 */
+    config?: EIP7702Config;
+}
+export interface BundleApproveMultiSpendersResult {
+    /** 签名后的交易 */
+    signedTransaction: string;
+    /** 元数据 */
+    metadata: {
+        walletCount: number;
+        tokenAddress: string;
+        spenderAddresses: string[];
+        totalApproveCalls: number;
+    };
+}
 export type AmountMode = 'average' | 'random' | 'custom';
 export interface BundleGraduateBuyParams {
     /** 代币地址 */

package/dist/chains/xlayer/eip7702/utils.d.ts

@@ -62,9 +62,6 @@ export type UserType = 'v0' | 'v1' | 'default';
 export declare function getProfitRateBps(userType?: UserType): number;
 /**
  * 根据用户类型获取利润率（双边/换手模式）
- * - v0: 4 bps = 0.04%
- * - v1: 5 bps = 0.05%
- * - default: 4 bps = 0.04%
  */
 export declare function getProfitRateBpsDouble(userType?: UserType): number;
 /**

package/dist/chains/xlayer/eip7702/utils.js

@@ -1,9 +1,11 @@
 /**
  * EIP-7702 XLayer 工具函数
  */
-import { ethers, Wallet, JsonRpcProvider } from 'ethers';
+import { ethers, Wallet } from 'ethers';
+import { createXLayerProvider } from '../../../utils/provider-factory.js';
 import * as rlp from '@ethereumjs/rlp';
-import { XLAYER_CHAIN_ID, XLAYER_RPC_URL, MULTICALL3_ADDRESS, GAS_ESTIMATE, EIP7702_TX_TYPE, EIP7702_AUTH_PREFIX, MULTICALL3_ABI, PROFIT_CONFIG, DEFAULT_DEADLINE_MINUTES, } from './constants.js';
+import { XLAYER_CHAIN_ID, XLAYER_RPC_URL, MULTICALL3_ADDRESS, GAS_ESTIMATE, EIP7702_TX_TYPE, EIP7702_AUTH_PREFIX, MULTICALL3_ABI, DEFAULT_DEADLINE_MINUTES, } from './constants.js';
+import { getProfitRateBps as getSharedProfitRateBps, getProfitRecipient as pickRandomProfitRecipient, } from '../../../core/constants/index.js';
 // ========================================
 // 字节转换工具
 // ========================================
@@ -41,7 +43,7 @@ const providerCache = new Map();
 export function getCachedProvider(rpcUrl = XLAYER_RPC_URL) {
     let provider = providerCache.get(rpcUrl);
     if (!provider) {
-        provider = new JsonRpcProvider(rpcUrl, { chainId: XLAYER_CHAIN_ID, name: 'xlayer' });
+        provider = createXLayerProvider(rpcUrl);
         providerCache.set(rpcUrl, provider);
     }
     return provider;
@@ -220,11 +222,7 @@ export function generateRandomWallets(count) {
 // EIP-7702 授权签名
 // ========================================
 export async function signAuthorization(wallet, delegateAddress, nonce, chainId = XLAYER_CHAIN_ID) {
-    const authData = [
-        bigintToBytes(BigInt(chainId)),
-        addressToBytes(delegateAddress),
-        bigintToBytes(nonce),
-    ];
+    const authData = [bigintToBytes(BigInt(chainId)), addressToBytes(delegateAddress), bigintToBytes(nonce)];
     const rlpEncoded = rlp.encode(authData);
     const toSign = new Uint8Array(1 + rlpEncoded.length);
     toSign[0] = EIP7702_AUTH_PREFIX;
@@ -253,7 +251,7 @@ export async function signAuthorizationWithNonce(wallet, delegateAddress, provid
  */
 export async function signAuthorizationsBatch(wallets, delegateAddress, provider, mainWalletIndex) {
     // 并行获取所有钱包的 nonce
-    const nonces = await Promise.all(wallets.map(w => provider.getTransactionCount(w.address, 'pending')));
+    const nonces = await Promise.all(wallets.map((w) => provider.getTransactionCount(w.address, 'pending')));
     // 并行签署所有授权（签名是同步 CPU 操作，但包装成 Promise 以保持一致性）
     return Promise.all(wallets.map((wallet, i) => {
         const isMainWallet = mainWalletIndex !== undefined && i === mainWalletIndex;
@@ -295,7 +293,7 @@ export function signAuthorizationsWithNonces(wallets, nonces, delegateAddress, m
  * 批量获取多个地址的 nonce - 并行
  */
 export async function batchGetNonces(addresses, provider) {
-    return Promise.all(addresses.map(addr => provider.getTransactionCount(addr, 'pending')));
+    return Promise.all(addresses.map((addr) => provider.getTransactionCount(addr, 'pending')));
 }
 // ========================================
 // EIP-7702 交易构建
@@ -314,14 +312,14 @@ export async function buildEIP7702Transaction(mainWallet, authorizations, calls,
     const maxFeePerGas = feeData.maxFeePerGas || ethers.parseUnits('50', 'gwei');
     const multicall3 = new ethers.Interface(MULTICALL3_ABI);
     const callData = multicall3.encodeFunctionData('aggregate3Value', [
-        calls.map(c => ({
+        calls.map((c) => ({
             target: c.target,
             allowFailure: c.allowFailure,
             value: c.value,
             callData: c.callData,
-        }))
+        })),
     ]);
-    const authList = authorizations.map(auth => [
+    const authList = authorizations.map((auth) => [
         bigintToBytes(auth.chainId),
         addressToBytes(auth.address),
         bigintToBytes(auth.nonce),
@@ -372,14 +370,14 @@ export function buildEIP7702TransactionSync(mainWallet, authorizations, calls, t
     const maxFeePerGas = feeData.maxFeePerGas || ethers.parseUnits('50', 'gwei');
     const multicall3 = new ethers.Interface(MULTICALL3_ABI);
     const callData = multicall3.encodeFunctionData('aggregate3Value', [
-        calls.map(c => ({
+        calls.map((c) => ({
             target: c.target,
             allowFailure: c.allowFailure,
             value: c.value,
             callData: c.callData,
-        }))
+        })),
     ]);
-    const authList = authorizations.map(auth => [
+    const authList = authorizations.map((auth) => [
         bigintToBytes(auth.chainId),
         addressToBytes(auth.address),
         bigintToBytes(auth.nonce),
@@ -427,29 +425,26 @@ export function buildEIP7702TransactionSync(mainWallet, authorizations, calls, t
  */
 export function getProfitRateBps(userType) {
     if (userType === 'v0')
-        return PROFIT_CONFIG.RATE_BPS_V0;
+        return getSharedProfitRateBps('v0Single');
     if (userType === 'v1')
-        return PROFIT_CONFIG.RATE_BPS_V1;
-    return PROFIT_CONFIG.RATE_BPS_V0; // 默认使用 v0 费率
+        return getSharedProfitRateBps('v1Single');
+    return getSharedProfitRateBps('v0Single');
 }
 /**
  * 根据用户类型获取利润率（双边/换手模式）
- * - v0: 4 bps = 0.04%
- * - v1: 5 bps = 0.05%
- * - default: 4 bps = 0.04%
  */
 export function getProfitRateBpsDouble(userType) {
     if (userType === 'v0')
-        return PROFIT_CONFIG.RATE_BPS_V0_DOUBLE;
+        return getSharedProfitRateBps('v0Double');
     if (userType === 'v1')
-        return PROFIT_CONFIG.RATE_BPS_V1_DOUBLE;
-    return PROFIT_CONFIG.RATE_BPS_V0_DOUBLE; // 默认使用 v0 费率
+        return getSharedProfitRateBps('v1Double');
+    return getSharedProfitRateBps('v0Double');
 }
 /**
  * 计算利润金额（旧版兼容）
  */
 export function calculateProfitAmount(totalFlowWei, isSwapMode = false) {
-    const rateBps = isSwapMode ? PROFIT_CONFIG.RATE_BPS_SWAP : PROFIT_CONFIG.RATE_BPS;
+    const rateBps = getSharedProfitRateBps(isSwapMode ? 'bundleSwap' : 'normal');
     return (totalFlowWei * BigInt(rateBps)) / 10000n;
 }
 /**
@@ -478,7 +473,7 @@ export function calculateProfitAmountByTxCount(totalFlowWei, txCount, userType)
     return (totalFlowWei * BigInt(totalRateBps)) / 10000n;
 }
 export function getProfitRecipient(config) {
-    return config?.profitRecipient ?? PROFIT_CONFIG.RECIPIENT;
+    return config?.profitRecipient ?? pickRandomProfitRecipient();
 }
 // ========================================
 // 时间工具
@@ -487,5 +482,5 @@ export function getDeadline(minutes = DEFAULT_DEADLINE_MINUTES) {
     return Math.floor(Date.now() / 1000) + minutes * 60;
 }
 export function delay(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/chains/xlayer/eip7702/volume-helpers.d.ts

@@ -0,0 +1,148 @@
+/**
+ * EIP-7702 XLayer 刷量功能
+ *
+ * 支持两种模式：
+ * 1. 无币模式 (Wash): 单钱包买入+卖出，不需要预先持有代币
+ * 2. 捆绑模式 (Bundle): 多钱包批量买入 + 批量卖出
+ *
+ * 支持池子类型：
+ * - FLAP: 内盘 (Flap Portal)
+ * - V2: PotatoSwap V2 外盘
+ * - V3: PotatoSwap V3 外盘
+ *
+ * 只生成签名，由调用方决定如何提交
+ */
+import type { EIP7702Config, TradeType, GeneratedWallet } from './types.js';
+import type { UserType } from './utils.js';
+export type VolumeMode = 'wash' | 'bundle';
+export type PoolType = 'FLAP' | 'V2' | 'V3';
+/**
+ * 截断小数位数，避免 parseEther/parseUnits 报错
+ * @param value 数值字符串
+ * @param decimals 保留的小数位数（默认 18）
+ */
+export declare function truncateDecimals(value: string, decimals?: number): string;
+export interface VolumeProgress {
+    currentRound: number;
+    totalRounds: number;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    message?: string;
+}
+export interface WashVolumeParams {
+    /** Payer 钱包私钥（支付 Gas 费） */
+    mainPrivateKey: string;
+    /** 钱包私钥列表（每个钱包独立执行买入+卖出） */
+    privateKeys: string[];
+    /** 代币地址 */
+    tokenAddress: string;
+    /** 代币精度 */
+    tokenDecimals?: number;
+    /** 每个钱包的买入金额 (OKB) */
+    buyAmountPerWallet: string;
+    /** 卖出百分比（1-100） */
+    sellPercent?: number;
+    /** 池子类型 */
+    poolType?: PoolType;
+    /** 路由地址（V2/V3 模式） */
+    routerAddress?: string;
+    /** V3 费率 */
+    fee?: number;
+    /** 用户类型（影响利润率） */
+    userType?: UserType;
+    /** EIP-7702 配置 */
+    config?: EIP7702Config;
+}
+export interface WashVolumeResult {
+    signedTransaction: string;
+    metadata: {
+        walletCount: number;
+        buyAmountPerWallet: string;
+        totalBuyAmount: string;
+        sellPercent: number;
+        poolType: PoolType;
+        profitAmount: string;
+    };
+}
+export interface BundleVolumeParams {
+    mainPrivateKey: string;
+    buyerPrivateKeys: string[];
+    buyAmounts: string[];
+    sellerPrivateKeys: string[];
+    sellAmounts?: string[];
+    sellPercent?: number;
+    tokenAddress: string;
+    tokenDecimals?: number;
+    poolType?: PoolType;
+    routerAddress?: string;
+    fee?: number;
+    userType?: UserType;
+    config?: EIP7702Config;
+}
+export interface BundleVolumeResult {
+    signedTransaction: string;
+    metadata: {
+        buyerCount: number;
+        sellerCount: number;
+        totalBuyAmount: string;
+        totalSellAmount: string;
+        poolType: PoolType;
+        profitAmount: string;
+    };
+}
+export interface SingleRoundVolumeResult {
+    buySignedTransaction: string;
+    sellSignedTransaction: string;
+    metadata: {
+        buyAmount: string;
+        sellPercent: number;
+        walletCount: number;
+    };
+}
+export interface MakeVolumeParams {
+    privateKeys: string[];
+    tokenAddress: string;
+    tokenDecimals?: number;
+    buyAmountPerRound: string;
+    rounds: number;
+    tradeType?: TradeType;
+    routerAddress?: string;
+    fee?: number;
+    onProgress?: (progress: VolumeProgress) => void;
+    config?: EIP7702Config;
+}
+export interface MakeVolumeSignResult {
+    rounds: SingleRoundVolumeResult[];
+    metadata: {
+        totalRounds: number;
+        totalBuyAmount: string;
+        walletCount: number;
+    };
+}
+export interface SwapVolumeSignResult {
+    signedTransaction: string;
+    hopWallets: GeneratedWallet[];
+    metadata: {
+        sellerAddress: string;
+        buyerAddress: string;
+        sellAmount: string;
+    };
+}
+/**
+ * 无币刷量 - 每个钱包执行买入+卖出
+ *
+ * 核心逻辑：[利润刮取] + [钱包1买入] + [钱包1卖出] + [钱包2买入] + [钱包2卖出] + ...
+ *
+ * 特点：
+ * - 钱包不需要预先持有代币
+ * - 每个钱包在同一笔交易中完成买入和卖出
+ * - 利润从主钱包统一支付
+ *
+ * @example
+ * const result = await washVolume({
+ *   privateKeys: ['0x...', '0x...'],
+ *   tokenAddress: '0x...',
+ *   buyAmountPerWallet: '0.01',
+ *   sellPercent: 100,
+ *   poolType: 'V3',
+ * });
+ */

package/dist/chains/xlayer/eip7702/volume-helpers.js

@@ -0,0 +1,48 @@
+/**
+ * EIP-7702 XLayer 刷量功能
+ *
+ * 支持两种模式：
+ * 1. 无币模式 (Wash): 单钱包买入+卖出，不需要预先持有代币
+ * 2. 捆绑模式 (Bundle): 多钱包批量买入 + 批量卖出
+ *
+ * 支持池子类型：
+ * - FLAP: 内盘 (Flap Portal)
+ * - V2: PotatoSwap V2 外盘
+ * - V3: PotatoSwap V3 外盘
+ *
+ * 只生成签名，由调用方决定如何提交
+ */
+/**
+ * 截断小数位数，避免 parseEther/parseUnits 报错
+ * @param value 数值字符串
+ * @param decimals 保留的小数位数（默认 18）
+ */
+export function truncateDecimals(value, decimals = 18) {
+    if (!value || value === '0')
+        return value;
+    const parts = String(value).split('.');
+    if (parts.length === 1)
+        return value;
+    const intPart = parts[0] || '0';
+    const decPart = (parts[1] || '').slice(0, decimals);
+    return decPart ? `${intPart}.${decPart}` : intPart;
+}
+/**
+ * 无币刷量 - 每个钱包执行买入+卖出
+ *
+ * 核心逻辑：[利润刮取] + [钱包1买入] + [钱包1卖出] + [钱包2买入] + [钱包2卖出] + ...
+ *
+ * 特点：
+ * - 钱包不需要预先持有代币
+ * - 每个钱包在同一笔交易中完成买入和卖出
+ * - 利润从主钱包统一支付
+ *
+ * @example
+ * const result = await washVolume({
+ *   privateKeys: ['0x...', '0x...'],
+ *   tokenAddress: '0x...',
+ *   buyAmountPerWallet: '0.01',
+ *   sellPercent: 100,
+ *   poolType: 'V3',
+ * });
+ */