four-flap-meme-sdk 1.4.91 → 1.4.93

package/dist/xlayer/types.d.ts

@@ -0,0 +1,298 @@
+/**
+ * XLayer SDK 类型定义
+ *
+ * 包含 ERC-4337 UserOperation、AA 账户、交易参数等核心类型
+ */
+import type { HexString } from './constants.js';
+/**
+ * UserOperation v0.6 结构
+ * 用于 ERC-4337 EntryPoint v0.6
+ */
+export interface UserOperation {
+    sender: string;
+    nonce: HexString | string;
+    initCode: HexString | string;
+    callData: HexString | string;
+    callGasLimit: HexString | string;
+    verificationGasLimit: HexString | string;
+    preVerificationGas: HexString | string;
+    maxFeePerGas: HexString | string;
+    maxPriorityFeePerGas: HexString | string;
+    paymasterAndData: HexString | string;
+    signature: HexString | string;
+}
+/**
+ * 签名后的 UserOperation（包含额外元数据）
+ */
+export interface SignedUserOp {
+    userOp: UserOperation;
+    userOpHash: string;
+    prefundWei: bigint;
+    sender: string;
+    ownerName?: string;
+}
+/**
+ * Gas 估算结果（来自 Bundler）
+ */
+export interface GasEstimate {
+    callGasLimit: HexString;
+    verificationGasLimit: HexString;
+    preVerificationGas: HexString;
+    maxFeePerGas?: HexString;
+    maxPriorityFeePerGas?: HexString;
+}
+/**
+ * XLayer SDK 基础配置
+ */
+export interface XLayerConfig {
+    /** RPC URL（默认使用公共节点） */
+    rpcUrl?: string;
+    /** Bundler URL（默认使用 Particle） */
+    bundlerUrl?: string;
+    /** Chain ID（默认 196） */
+    chainId?: number;
+    /** EntryPoint 地址 */
+    entryPoint?: string;
+    /** SimpleAccountFactory 地址 */
+    factory?: string;
+    /** Salt（用于 AA 账户派生） */
+    salt?: bigint;
+    /** Paymaster 地址（如果指定，不需要往 AA 转手续费） */
+    paymaster?: string;
+    /** Paymaster Data（与 paymaster 一起使用） */
+    paymasterData?: string;
+    /** 默认超时时间（毫秒） */
+    timeoutMs?: number;
+    /** Gas 估算安全余量倍数 */
+    gasLimitMultiplier?: number;
+}
+/**
+ * AA 账户信息
+ */
+export interface AAAccount {
+    /** Owner EOA 地址 */
+    owner: string;
+    /** AA Sender 地址 */
+    sender: string;
+    /** 是否已部署 */
+    deployed: boolean;
+    /** OKB 余额 */
+    balance: bigint;
+    /** Nonce */
+    nonce: bigint;
+}
+/**
+ * Owner 钱包信息
+ */
+export interface OwnerInfo {
+    name: string;
+    privateKey: string;
+    address?: string;
+    sender?: string;
+}
+/**
+ * 买入参数
+ */
+export interface BuyParams {
+    /** Flap 代币地址 */
+    tokenAddress: string;
+    /** 买入金额（OKB，字符串格式） */
+    amountOkb: string;
+    /** 最小输出代币数量（默认 0） */
+    minOutputAmount?: bigint;
+    /** 滑点基点（默认 100 = 1%） */
+    slippageBps?: number;
+}
+/**
+ * 卖出参数
+ */
+export interface SellParams {
+    /** Flap 代币地址 */
+    tokenAddress: string;
+    /** 卖出代币数量（可选，默认全部） */
+    amount?: bigint;
+    /** 卖出比例（0-100，如 50 表示卖出 50%） */
+    sellPercent?: number;
+    /** 最小输出 OKB 数量（默认 0） */
+    minOutputAmount?: bigint;
+    /** 滑点基点（默认 100 = 1%） */
+    slippageBps?: number;
+}
+/**
+ * 捆绑买入参数
+ */
+export interface BundleBuyParams {
+    /** 代币地址 */
+    tokenAddress: string;
+    /** Owner 私钥列表 */
+    privateKeys: string[];
+    /** 每个 owner 的买入金额（OKB） */
+    buyAmounts: string[];
+    /** 是否将代币转回 owner EOA（默认 false） */
+    transferBackToOwner?: boolean;
+    /** 配置覆盖 */
+    config?: Partial<XLayerConfig>;
+}
+/**
+ * 捆绑卖出参数
+ */
+export interface BundleSellParams {
+    /** 代币地址 */
+    tokenAddress: string;
+    /** Owner 私钥列表 */
+    privateKeys: string[];
+    /** 卖出比例（0-100，默认 100 全部卖出） */
+    sellPercent?: number;
+    /** 是否将 OKB 归集回 owner EOA（默认 true） */
+    withdrawToOwner?: boolean;
+    /** 归集时保留的最小 OKB 余额 */
+    withdrawReserve?: string;
+    /** 配置覆盖 */
+    config?: Partial<XLayerConfig>;
+}
+/**
+ * 捆绑买卖参数（先买后卖）
+ */
+export interface BundleBuySellParams {
+    /** 代币地址 */
+    tokenAddress: string;
+    /** Owner 私钥列表 */
+    privateKeys: string[];
+    /** 每个 owner 的买入金额（OKB） */
+    buyAmounts: string[];
+    /** 卖出比例（0-100，默认 100 全部卖出） */
+    sellPercent?: number;
+    /** 是否将 OKB 归集回 owner EOA（默认 true） */
+    withdrawToOwner?: boolean;
+    /** 归集时保留的最小 OKB 余额 */
+    withdrawReserve?: string;
+    /** 配置覆盖 */
+    config?: Partial<XLayerConfig>;
+}
+/**
+ * 刷量参数
+ */
+export interface VolumeParams {
+    /** 代币地址 */
+    tokenAddress: string;
+    /** Owner 私钥列表 */
+    privateKeys: string[];
+    /** 每轮买入金额（OKB） */
+    buyAmountPerRound: string;
+    /** 刷量轮数 */
+    rounds: number;
+    /** 每轮间隔时间（毫秒，默认 3000） */
+    intervalMs?: number;
+    /** 每轮是否立即卖出（默认 true） */
+    sellImmediately?: boolean;
+    /** 配置覆盖 */
+    config?: Partial<XLayerConfig>;
+}
+/**
+ * handleOps 执行结果
+ */
+export interface HandleOpsResult {
+    /** 交易哈希 */
+    txHash: string;
+    /** 区块号 */
+    blockNumber: number;
+    /** 交易状态 */
+    status: number;
+    /** UserOperationEvent 列表 */
+    userOpEvents: UserOpEventResult[];
+}
+/**
+ * UserOperationEvent 解析结果
+ */
+export interface UserOpEventResult {
+    userOpHash: string;
+    sender: string;
+    paymaster: string;
+    success: boolean;
+    actualGasCost: bigint;
+    actualGasUsed: bigint;
+}
+/**
+ * 捆绑买入结果
+ */
+export interface BundleBuyResult {
+    /** 买入交易结果 */
+    buyResult: HandleOpsResult;
+    /** 转账交易结果（如果 transferBackToOwner） */
+    transferResult?: HandleOpsResult;
+    /** 各 sender 的代币余额 */
+    tokenBalances: Map<string, bigint>;
+}
+/**
+ * 捆绑卖出结果
+ */
+export interface BundleSellResult {
+    /** 授权交易结果（如果需要） */
+    approveResult?: HandleOpsResult;
+    /** 卖出交易结果 */
+    sellResult: HandleOpsResult;
+    /** 归集交易结果（如果 withdrawToOwner） */
+    withdrawResult?: HandleOpsResult;
+}
+/**
+ * 捆绑买卖结果
+ */
+export interface BundleBuySellResult {
+    /** 买入阶段结果 */
+    buyResult: HandleOpsResult;
+    /** 授权阶段结果（如果需要） */
+    approveResult?: HandleOpsResult;
+    /** 卖出阶段结果 */
+    sellResult: HandleOpsResult;
+    /** 归集阶段结果（如果 withdrawToOwner） */
+    withdrawResult?: HandleOpsResult;
+    /** 各 sender 的最终 OKB 余额 */
+    finalBalances: Map<string, bigint>;
+}
+/**
+ * 刷量结果
+ */
+export interface VolumeResult {
+    /** 成功轮数 */
+    successRounds: number;
+    /** 失败轮数 */
+    failedRounds: number;
+    /** 每轮结果 */
+    roundResults: BundleBuySellResult[];
+    /** 总交易量（OKB） */
+    totalVolume: bigint;
+}
+/**
+ * 外盘（PotatoSwap）交易参数
+ */
+export interface DexSwapParams {
+    /** 输入代币地址（零地址表示 OKB） */
+    inputToken: string;
+    /** 输出代币地址（零地址表示 OKB） */
+    outputToken: string;
+    /** 输入金额 */
+    inputAmount: bigint;
+    /** 最小输出金额 */
+    minOutputAmount: bigint;
+    /** 交易截止时间（默认 20 分钟） */
+    deadline?: number;
+}
+/**
+ * 外盘交易结果
+ */
+export interface DexSwapResult {
+    txHash: string;
+    inputAmount: bigint;
+    outputAmount: bigint;
+    gasUsed: bigint;
+}
+/**
+ * 深度 Partial 类型
+ */
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+/**
+ * 必需的配置字段
+ */
+export type RequiredConfig = Required<Pick<XLayerConfig, 'rpcUrl' | 'bundlerUrl' | 'chainId' | 'entryPoint' | 'factory'>>;

package/dist/xlayer/types.js

@@ -0,0 +1,6 @@
+/**
+ * XLayer SDK 类型定义
+ *
+ * 包含 ERC-4337 UserOperation、AA 账户、交易参数等核心类型
+ */
+export {};

package/dist/xlayer/volume.d.ts

@@ -0,0 +1,65 @@
+/**
+ * XLayer 刷量/做市 SDK
+ *
+ * 通过多轮买卖循环实现刷量：
+ * - 多地址轮转刷量
+ * - 可配置买卖间隔
+ * - 支持部分卖出
+ * - 自动归集
+ */
+import type { XLayerConfig, VolumeParams, VolumeResult, BundleBuySellResult } from './types.js';
+/**
+ * 刷量执行器
+ *
+ * 通过多轮买卖循环制造交易量
+ */
+export declare class VolumeExecutor {
+    private bundleExecutor;
+    private config;
+    constructor(config?: XLayerConfig);
+    /**
+     * 执行刷量
+     *
+     * @param params 刷量参数
+     * @returns 刷量结果
+     */
+    execute(params: VolumeParams): Promise<VolumeResult>;
+    /**
+     * 单轮刷量（简化接口）
+     */
+    singleRound(params: Omit<VolumeParams, 'rounds' | 'intervalMs'>): Promise<BundleBuySellResult>;
+    /**
+     * 轮转刷量（每轮使用不同地址子集）
+     */
+    rotatingVolume(params: {
+        tokenAddress: string;
+        allPrivateKeys: string[];
+        ownersPerRound: number;
+        buyAmountPerOwner: string;
+        rounds: number;
+        intervalMs?: number;
+    }): Promise<VolumeResult>;
+    /**
+     * 随机金额刷量
+     */
+    randomAmountVolume(params: {
+        tokenAddress: string;
+        privateKeys: string[];
+        minBuyAmount: string;
+        maxBuyAmount: string;
+        rounds: number;
+        intervalMs?: number;
+    }): Promise<VolumeResult>;
+}
+/**
+ * 创建刷量执行器
+ */
+export declare function createVolumeExecutor(config?: XLayerConfig): VolumeExecutor;
+/**
+ * 快速刷量
+ */
+export declare function makeVolume(params: VolumeParams): Promise<VolumeResult>;
+/**
+ * 单轮刷量
+ */
+export declare function singleRoundVolume(params: Omit<VolumeParams, 'rounds' | 'intervalMs'>): Promise<BundleBuySellResult>;

package/dist/xlayer/volume.js

@@ -0,0 +1,235 @@
+/**
+ * XLayer 刷量/做市 SDK
+ *
+ * 通过多轮买卖循环实现刷量：
+ * - 多地址轮转刷量
+ * - 可配置买卖间隔
+ * - 支持部分卖出
+ * - 自动归集
+ */
+import { createBundleExecutor } from './bundle.js';
+import { parseOkb, formatOkb } from './portal-ops.js';
+// ============================================================================
+// 刷量执行器
+// ============================================================================
+/**
+ * 刷量执行器
+ *
+ * 通过多轮买卖循环制造交易量
+ */
+export class VolumeExecutor {
+    constructor(config = {}) {
+        this.config = config;
+        this.bundleExecutor = createBundleExecutor(config);
+    }
+    /**
+     * 执行刷量
+     *
+     * @param params 刷量参数
+     * @returns 刷量结果
+     */
+    async execute(params) {
+        const { tokenAddress, privateKeys, buyAmountPerRound, rounds, intervalMs = 3000, sellImmediately = true, } = params;
+        console.log('=== XLayer Volume Maker ===');
+        console.log('token:', tokenAddress);
+        console.log('owners:', privateKeys.length);
+        console.log('rounds:', rounds);
+        console.log('buyAmountPerRound:', buyAmountPerRound, 'OKB');
+        console.log('intervalMs:', intervalMs);
+        console.log('sellImmediately:', sellImmediately);
+        const roundResults = [];
+        let successRounds = 0;
+        let failedRounds = 0;
+        let totalVolume = 0n;
+        const buyWei = parseOkb(buyAmountPerRound);
+        for (let round = 0; round < rounds; round++) {
+            console.log(`\n========== Round ${round + 1}/${rounds} ==========`);
+            try {
+                // 为每个 owner 分配相同的买入金额
+                const buyAmounts = privateKeys.map(() => buyAmountPerRound);
+                const result = await this.bundleExecutor.bundleBuySell({
+                    tokenAddress,
+                    privateKeys,
+                    buyAmounts,
+                    sellPercent: sellImmediately ? 100 : 0,
+                    withdrawToOwner: true,
+                    config: this.config,
+                });
+                roundResults.push(result);
+                successRounds++;
+                totalVolume += buyWei * BigInt(privateKeys.length);
+                console.log(`Round ${round + 1} 完成`);
+            }
+            catch (error) {
+                console.error(`Round ${round + 1} 失败:`, error);
+                failedRounds++;
+            }
+            // 等待间隔
+            if (round < rounds - 1 && intervalMs > 0) {
+                console.log(`等待 ${intervalMs}ms...`);
+                await sleep(intervalMs);
+            }
+        }
+        console.log('\n=== Volume Summary ===');
+        console.log('成功轮数:', successRounds);
+        console.log('失败轮数:', failedRounds);
+        console.log('总交易量:', formatOkb(totalVolume), 'OKB');
+        return {
+            successRounds,
+            failedRounds,
+            roundResults,
+            totalVolume,
+        };
+    }
+    /**
+     * 单轮刷量（简化接口）
+     */
+    async singleRound(params) {
+        const buyAmounts = params.privateKeys.map(() => params.buyAmountPerRound);
+        return this.bundleExecutor.bundleBuySell({
+            tokenAddress: params.tokenAddress,
+            privateKeys: params.privateKeys,
+            buyAmounts,
+            sellPercent: params.sellImmediately !== false ? 100 : 0,
+            withdrawToOwner: true,
+            config: this.config,
+        });
+    }
+    /**
+     * 轮转刷量（每轮使用不同地址子集）
+     */
+    async rotatingVolume(params) {
+        const { tokenAddress, allPrivateKeys, ownersPerRound, buyAmountPerOwner, rounds, intervalMs = 3000, } = params;
+        console.log('=== XLayer Rotating Volume ===');
+        console.log('token:', tokenAddress);
+        console.log('totalOwners:', allPrivateKeys.length);
+        console.log('ownersPerRound:', ownersPerRound);
+        console.log('rounds:', rounds);
+        const roundResults = [];
+        let successRounds = 0;
+        let failedRounds = 0;
+        let totalVolume = 0n;
+        const buyWei = parseOkb(buyAmountPerOwner);
+        for (let round = 0; round < rounds; round++) {
+            // 轮转选择地址
+            const startIdx = (round * ownersPerRound) % allPrivateKeys.length;
+            const selectedKeys = [];
+            for (let i = 0; i < ownersPerRound; i++) {
+                const idx = (startIdx + i) % allPrivateKeys.length;
+                selectedKeys.push(allPrivateKeys[idx]);
+            }
+            console.log(`\n========== Round ${round + 1}/${rounds} (owners: ${startIdx}-${startIdx + ownersPerRound - 1}) ==========`);
+            try {
+                const buyAmounts = selectedKeys.map(() => buyAmountPerOwner);
+                const result = await this.bundleExecutor.bundleBuySell({
+                    tokenAddress,
+                    privateKeys: selectedKeys,
+                    buyAmounts,
+                    sellPercent: 100,
+                    withdrawToOwner: true,
+                    config: this.config,
+                });
+                roundResults.push(result);
+                successRounds++;
+                totalVolume += buyWei * BigInt(ownersPerRound);
+            }
+            catch (error) {
+                console.error(`Round ${round + 1} 失败:`, error);
+                failedRounds++;
+            }
+            if (round < rounds - 1 && intervalMs > 0) {
+                await sleep(intervalMs);
+            }
+        }
+        return {
+            successRounds,
+            failedRounds,
+            roundResults,
+            totalVolume,
+        };
+    }
+    /**
+     * 随机金额刷量
+     */
+    async randomAmountVolume(params) {
+        const { tokenAddress, privateKeys, minBuyAmount, maxBuyAmount, rounds, intervalMs = 3000, } = params;
+        console.log('=== XLayer Random Amount Volume ===');
+        console.log('token:', tokenAddress);
+        console.log('owners:', privateKeys.length);
+        console.log('buyRange:', minBuyAmount, '-', maxBuyAmount, 'OKB');
+        console.log('rounds:', rounds);
+        const roundResults = [];
+        let successRounds = 0;
+        let failedRounds = 0;
+        let totalVolume = 0n;
+        const minWei = parseOkb(minBuyAmount);
+        const maxWei = parseOkb(maxBuyAmount);
+        const range = maxWei - minWei;
+        for (let round = 0; round < rounds; round++) {
+            console.log(`\n========== Round ${round + 1}/${rounds} ==========`);
+            try {
+                // 为每个 owner 生成随机金额
+                const buyAmounts = [];
+                let roundVolume = 0n;
+                for (let i = 0; i < privateKeys.length; i++) {
+                    const randomWei = minWei + BigInt(Math.floor(Math.random() * Number(range)));
+                    buyAmounts.push(formatOkb(randomWei));
+                    roundVolume += randomWei;
+                }
+                const result = await this.bundleExecutor.bundleBuySell({
+                    tokenAddress,
+                    privateKeys,
+                    buyAmounts,
+                    sellPercent: 100,
+                    withdrawToOwner: true,
+                    config: this.config,
+                });
+                roundResults.push(result);
+                successRounds++;
+                totalVolume += roundVolume;
+            }
+            catch (error) {
+                console.error(`Round ${round + 1} 失败:`, error);
+                failedRounds++;
+            }
+            if (round < rounds - 1 && intervalMs > 0) {
+                await sleep(intervalMs);
+            }
+        }
+        return {
+            successRounds,
+            failedRounds,
+            roundResults,
+            totalVolume,
+        };
+    }
+}
+// ============================================================================
+// 便捷函数
+// ============================================================================
+/**
+ * 创建刷量执行器
+ */
+export function createVolumeExecutor(config) {
+    return new VolumeExecutor(config);
+}
+/**
+ * 快速刷量
+ */
+export async function makeVolume(params) {
+    const executor = createVolumeExecutor(params.config);
+    return executor.execute(params);
+}
+/**
+ * 单轮刷量
+ */
+export async function singleRoundVolume(params) {
+    const executor = createVolumeExecutor(params.config);
+    return executor.singleRound(params);
+}
+// ============================================================================
+// 工具函数
+// ============================================================================
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "four-flap-meme-sdk",
-  "version": "1.4.91",
+  "version": "1.4.93",
   "description": "SDK for Flap bonding curve and four.meme TokenManager",
   "type": "module",
   "main": "dist/index.js",