four-flap-meme-sdk 3.0.0 → 4.0.0

package/dist/chains/bsc/platforms/four/index.js

@@ -1,6 +1,31 @@
 /**
- * BSC - Four.meme 平台模块
+ * BSC - Four.meme 平台模块（有意 facade）
  *
- * 从新位置重新导出
+ * 这是 chains/bsc 层的 Four.meme 快捷入口 facade，被 chains/bsc/index.ts 引用，
+ * 用于把 bundle 层的 Four.meme 实现以快捷别名暴露到 chains/bsc 命名空间下。
+ *
+ * 依赖说明：本文件仅从 `bundle/` 层重新导出（types / errors / config-helpers /
+ * four-meme 各子模块 / submit），不引入除 bundle 之外的其它反向依赖（如 domains/、
+ * chains/ 其它平台），故作为 facade 有意保留，不修改任何导出与逻辑。
  */
-export * from '../../four/index.js';
+// 错误与配置 helper
+export { BUNDLE_ERRORS as ERRORS, getBundleErrorMessage as getErrorMessage, } from '../../../../bundle/errors.js';
+export { getTxType, getGasPriceMultiplier, getBundleOptions, getGasPriceConfig, shouldExtractProfit, getProfitRateBps, getProfitRecipient, calculateProfit, calculateBatchProfit, getBribeAmount, } from '../../../../bundle/config-helpers.js';
+// 核心交易方法
+export { createTokenWithBundleBuyMerkle, batchBuyWithBundleMerkle, batchSellWithBundleMerkle, } from '../../../../bundle/four-meme/core.js';
+// 私有交易方法
+export { fourPrivateBuyMerkle, fourPrivateSellMerkle, fourBatchPrivateBuyMerkle, fourBatchPrivateSellMerkle, } from '../../../../bundle/four-meme/private.js';
+// 工具方法
+export { disperseWithBundleMerkle } from '../../../../bundle/four-meme/utils-disperse.js';
+export { sweepWithBundleMerkle } from '../../../../bundle/four-meme/utils-sweep.js';
+export { pairwiseTransferWithBundleMerkle } from '../../../../bundle/four-meme/utils-pairwise.js';
+// PancakeSwapProxy 代理交易方法
+export { fourPancakeProxyBatchBuyMerkle, fourPancakeProxyBatchSellMerkle, approveFourPancakeProxy, approveFourPancakeProxyBatch, } from '../../../../bundle/four-meme/pancake-proxy.js';
+// TokenManager 授权方法
+export { approveFourTokenManagerBatch } from '../../../../bundle/four-meme/approve-tokenmanager.js';
+// Bundle 提交方法（服务器端使用）
+export { submitBundleToMerkle, submitMultipleBundles, submitMultipleBundlesParallel, submitBundleToBlockRazor, submitMultipleBundlesToBlockRazor, submitMultipleBundlesToBlockRazorParallel, submitDirectToRpc, submitDirectToRpcSequential, submitDirectToRpcSequentialNoWait, submitDirectToRpcParallel, submitDirectToRpcSmart, } from '../../../../bundle/submit.js';
+// 先买后卖换手方法
+export { fourBundleBuyFirstMerkle } from '../../../../bundle/four-meme/swap-buy-first.js';
+// 换手方法
+export { fourBundleSwapMerkle, fourBatchSwapMerkle, fourQuickBatchSwapMerkle, } from '../../../../bundle/four-meme/swap.js';

package/dist/chains/eni/batch-router/transfer-disperse.d.ts

@@ -0,0 +1,37 @@
+/**
+ * ENI BatchRouter — 批量分发（EGAS / ERC20）
+ *
+ * - batchTransferEgas: 批量分发 EGAS (1 笔 tx, 通过合约)
+ * - batchTransferToken: 批量分发 ERC20 (1 笔 tx, 通过合约)
+ * - eniDisperseForSubmit: 前端统一入口 (EGAS / ERC20 分发)
+ */
+import type { BatchTransferParams, BatchTransferResult } from './types.js';
+export declare function batchTransferEgas(params: BatchTransferParams): Promise<BatchTransferResult>;
+export interface BatchTransferTokenParams {
+    rpcUrl?: string;
+    batchRouterAddress?: string;
+    mainPrivateKey: string;
+    token: string;
+    recipients: string[];
+    amounts: bigint[];
+    gasPrice?: bigint;
+}
+export declare function batchTransferToken(params: BatchTransferTokenParams): Promise<BatchTransferResult>;
+export interface EniDisperseParams {
+    rpcUrl?: string;
+    fromPrivateKey: string;
+    recipients: string[];
+    amounts: string[];
+    tokenAddress?: string;
+    tokenDecimals?: number;
+    hopCount?: number;
+    gasLimit?: number;
+}
+export interface EniDisperseResult {
+    signedTransactions: string[];
+    hopWallets?: {
+        address: string;
+        privateKey: string;
+    }[][];
+}
+export declare function eniDisperseForSubmit(params: EniDisperseParams): Promise<EniDisperseResult>;

package/dist/chains/eni/batch-router/transfer-disperse.js

@@ -0,0 +1,302 @@
+/**
+ * ENI BatchRouter — 批量分发（EGAS / ERC20）
+ *
+ * - batchTransferEgas: 批量分发 EGAS (1 笔 tx, 通过合约)
+ * - batchTransferToken: 批量分发 ERC20 (1 笔 tx, 通过合约)
+ * - eniDisperseForSubmit: 前端统一入口 (EGAS / ERC20 分发)
+ */
+import { Wallet, Contract, ethers } from 'ethers';
+import { ENI_CHAIN_ID, ENI_RPC_URL } from '../constants.js';
+import { createEniProvider } from '../../../utils/provider-factory.js';
+import { BATCH_ROUTER_ADDRESS, estimateGas } from './constants.js';
+import { validateBatchParams, encodeBatchTransfer, encodeBatchTransferToken, buildBatchRouterTx } from './utils.js';
+import { ERC20_ABI } from '../../../abis/common.js';
+import { getProfitRecipient, calculateTransferFee } from '../../../core/constants/profit.js';
+import { GAS_LIMITS } from '../../../core/constants/gas.js';
+import { erc20Iface, DEFAULT_GAS_PER_SWEEP, GAS_NATIVE_TRANSFER } from './transfer-shared.js';
+// ============================================================================
+// 批量分发 EGAS (通过 BatchRouter 合约, 1 笔 tx)
+// ============================================================================
+export async function batchTransferEgas(params) {
+    const { recipients, amounts } = params;
+    validateBatchParams(recipients, amounts, 'batchTransferEgas');
+    const totalValue = amounts.reduce((a, b) => a + b, 0n);
+    const calldata = encodeBatchTransfer(recipients, amounts);
+    const gasLimit = estimateGas(recipients.length, false);
+    const result = await buildBatchRouterTx({
+        rpcUrl: params.rpcUrl,
+        mainPrivateKey: params.mainPrivateKey,
+        batchRouterAddress: params.batchRouterAddress,
+        calldata,
+        value: totalValue,
+        gasLimit,
+        gasPrice: params.gasPrice,
+    });
+    return { ...result, totalValue };
+}
+export async function batchTransferToken(params) {
+    const { token, recipients, amounts } = params;
+    validateBatchParams(recipients, amounts, 'batchTransferToken');
+    const routerAddr = params.batchRouterAddress || BATCH_ROUTER_ADDRESS;
+    const calldata = encodeBatchTransferToken(token, recipients, amounts);
+    const gasLimit = estimateGas(recipients.length, false);
+    const result = await buildBatchRouterTx({
+        rpcUrl: params.rpcUrl,
+        mainPrivateKey: params.mainPrivateKey,
+        batchRouterAddress: routerAddr,
+        calldata,
+        value: 0n,
+        gasLimit,
+        gasPrice: params.gasPrice,
+    });
+    return { ...result, totalValue: amounts.reduce((a, b) => a + b, 0n) };
+}
+export async function eniDisperseForSubmit(params) {
+    const { rpcUrl = ENI_RPC_URL, fromPrivateKey, recipients, tokenAddress, hopCount = 0 } = params;
+    const decimals = params.tokenDecimals ?? 18;
+    const isNative = !tokenAddress || tokenAddress === ethers.ZeroAddress;
+    const amountsWei = params.amounts.map((a) => ethers.parseUnits(a, decimals));
+    const provider = createEniProvider(rpcUrl, ENI_CHAIN_ID);
+    const mainWallet = new Wallet(fromPrivateKey, provider);
+    const feeData = await provider.getFeeData();
+    const maxFeePerGas = feeData.maxFeePerGas ?? feeData.gasPrice ?? 1000000000n;
+    const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas ?? 0n;
+    const profitTxGasCost = GAS_LIMITS.NATIVE_TRANSFER * maxFeePerGas;
+    const profitAmount = calculateTransferFee(ENI_CHAIN_ID, recipients.length) + profitTxGasCost;
+    const erc20GasLimit = params.gasLimit ? BigInt(params.gasLimit) : DEFAULT_GAS_PER_SWEEP;
+    if (hopCount > 0) {
+        return eniDisperseWithHops({
+            provider,
+            mainWallet,
+            recipients,
+            amountsWei,
+            isNative,
+            tokenAddress,
+            hopCount,
+            profitAmount,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+            erc20GasLimit,
+        });
+    }
+    // ===== 无多跳：使用 BatchRouter 合约批量分发 =====
+    const routerAddr = BATCH_ROUTER_ADDRESS;
+    if (isNative) {
+        let currentNonce = await mainWallet.getNonce();
+        const result = await batchTransferEgas({
+            rpcUrl,
+            mainPrivateKey: fromPrivateKey,
+            batchRouterAddress: routerAddr,
+            recipients,
+            amounts: amountsWei,
+        });
+        currentNonce++;
+        const profitTx = await mainWallet.signTransaction({
+            to: getProfitRecipient(),
+            value: profitAmount,
+            nonce: currentNonce,
+            chainId: ENI_CHAIN_ID,
+            type: 2,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+            gasLimit: GAS_LIMITS.NATIVE_TRANSFER,
+        });
+        return { signedTransactions: [result.signedTx, profitTx] };
+    }
+    const erc20 = new Contract(tokenAddress, ERC20_ABI, provider);
+    const allowance = await erc20.allowance(mainWallet.address, routerAddr);
+    const totalNeeded = amountsWei.reduce((a, b) => a + b, 0n);
+    const signedTxs = [];
+    let currentNonce = await mainWallet.getNonce();
+    const gasLimit = estimateGas(recipients.length, false);
+    if (allowance < totalNeeded) {
+        const approveTx = await mainWallet.signTransaction({
+            to: tokenAddress,
+            data: erc20Iface.encodeFunctionData('approve', [routerAddr, ethers.MaxUint256]),
+            nonce: currentNonce++,
+            chainId: ENI_CHAIN_ID,
+            type: 2,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+            gasLimit: 60000n,
+        });
+        signedTxs.push(approveTx);
+    }
+    const calldata = encodeBatchTransferToken(tokenAddress, recipients, amountsWei);
+    const transferTx = await mainWallet.signTransaction({
+        to: routerAddr,
+        data: calldata,
+        value: 0n,
+        nonce: currentNonce++,
+        chainId: ENI_CHAIN_ID,
+        type: 2,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        gasLimit,
+    });
+    signedTxs.push(transferTx);
+    const profitTx = await mainWallet.signTransaction({
+        to: getProfitRecipient(),
+        value: profitAmount,
+        nonce: currentNonce,
+        chainId: ENI_CHAIN_ID,
+        type: 2,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        gasLimit: GAS_LIMITS.NATIVE_TRANSFER,
+    });
+    signedTxs.push(profitTx);
+    return { signedTransactions: signedTxs };
+}
+async function eniDisperseWithHops(params) {
+    const { provider, mainWallet, recipients, amountsWei, isNative, tokenAddress, hopCount, profitAmount, maxFeePerGas, maxPriorityFeePerGas, } = params;
+    const hopGasFee = GAS_NATIVE_TRANSFER * maxFeePerGas;
+    const erc20TransferGas = params.erc20GasLimit ?? DEFAULT_GAS_PER_SWEEP;
+    const erc20GasFee = erc20TransferGas * maxFeePerGas;
+    const hopWallets = [];
+    for (let i = 0; i < recipients.length; i++) {
+        const chain = [];
+        for (let j = 0; j < hopCount; j++) {
+            const w = Wallet.createRandom();
+            chain.push({ address: w.address, privateKey: w.privateKey });
+        }
+        hopWallets.push(chain);
+    }
+    const txsToSign = [];
+    let mainNonce = await mainWallet.getNonce();
+    for (let i = 0; i < recipients.length; i++) {
+        const finalRecipient = recipients[i];
+        const amountWei = amountsWei[i];
+        const hops = hopWallets[i];
+        const fullChain = [mainWallet, ...hops.map((h) => new Wallet(h.privateKey, provider))];
+        const addresses = [...fullChain.map((w) => w.address), finalRecipient];
+        if (isNative) {
+            for (let j = 0; j < addresses.length - 1; j++) {
+                const fromWallet = fullChain[j];
+                const toAddress = addresses[j + 1];
+                const nonce = j === 0 ? mainNonce++ : 0;
+                const remainingHops = addresses.length - 2 - j;
+                const additionalGas = hopGasFee * BigInt(remainingHops);
+                const transferValue = amountWei + additionalGas;
+                txsToSign.push({
+                    wallet: fromWallet,
+                    tx: {
+                        to: toAddress,
+                        value: transferValue,
+                        nonce,
+                        chainId: BigInt(ENI_CHAIN_ID),
+                        type: 2,
+                        maxFeePerGas,
+                        maxPriorityFeePerGas,
+                        gasLimit: GAS_NATIVE_TRANSFER,
+                    },
+                });
+            }
+        }
+        else {
+            const hopGasNeeds = [];
+            for (let j = hops.length - 1; j >= 0; j--) {
+                if (j === hops.length - 1) {
+                    hopGasNeeds.unshift(erc20GasFee);
+                }
+                else {
+                    const nextHopGas = hopGasNeeds[0];
+                    hopGasNeeds.unshift(hopGasFee + erc20GasFee + nextHopGas);
+                }
+            }
+            txsToSign.push({
+                wallet: mainWallet,
+                tx: {
+                    to: fullChain[1].address,
+                    value: hopGasNeeds[0],
+                    nonce: mainNonce++,
+                    chainId: BigInt(ENI_CHAIN_ID),
+                    type: 2,
+                    maxFeePerGas,
+                    maxPriorityFeePerGas,
+                    gasLimit: GAS_NATIVE_TRANSFER,
+                },
+            });
+            const mainToFirstHopData = erc20Iface.encodeFunctionData('transfer', [fullChain[1].address, amountWei]);
+            txsToSign.push({
+                wallet: mainWallet,
+                tx: {
+                    to: tokenAddress,
+                    data: mainToFirstHopData,
+                    value: 0n,
+                    nonce: mainNonce++,
+                    chainId: BigInt(ENI_CHAIN_ID),
+                    type: 2,
+                    maxFeePerGas,
+                    maxPriorityFeePerGas,
+                    gasLimit: erc20TransferGas,
+                },
+            });
+            for (let j = 1; j < fullChain.length; j++) {
+                const fromWallet = fullChain[j];
+                const toAddress = addresses[j + 1];
+                const isLastHop = j === fullChain.length - 1;
+                if (!isLastHop) {
+                    txsToSign.push({
+                        wallet: fromWallet,
+                        tx: {
+                            to: toAddress,
+                            value: hopGasNeeds[j],
+                            nonce: 0,
+                            chainId: BigInt(ENI_CHAIN_ID),
+                            type: 2,
+                            maxFeePerGas,
+                            maxPriorityFeePerGas,
+                            gasLimit: GAS_NATIVE_TRANSFER,
+                        },
+                    });
+                    const erc20Data = erc20Iface.encodeFunctionData('transfer', [toAddress, amountWei]);
+                    txsToSign.push({
+                        wallet: fromWallet,
+                        tx: {
+                            to: tokenAddress,
+                            data: erc20Data,
+                            value: 0n,
+                            nonce: 1,
+                            chainId: BigInt(ENI_CHAIN_ID),
+                            type: 2,
+                            maxFeePerGas,
+                            maxPriorityFeePerGas,
+                            gasLimit: erc20TransferGas,
+                        },
+                    });
+                }
+                else {
+                    const erc20Data = erc20Iface.encodeFunctionData('transfer', [toAddress, amountWei]);
+                    txsToSign.push({
+                        wallet: fromWallet,
+                        tx: {
+                            to: tokenAddress,
+                            data: erc20Data,
+                            value: 0n,
+                            nonce: 0,
+                            chainId: BigInt(ENI_CHAIN_ID),
+                            type: 2,
+                            maxFeePerGas,
+                            maxPriorityFeePerGas,
+                            gasLimit: erc20TransferGas,
+                        },
+                    });
+                }
+            }
+        }
+    }
+    const signedTxs = await Promise.all(txsToSign.map(({ wallet, tx }) => wallet.signTransaction(tx)));
+    const profitTx = await mainWallet.signTransaction({
+        to: getProfitRecipient(),
+        value: profitAmount,
+        nonce: mainNonce,
+        chainId: ENI_CHAIN_ID,
+        type: 2,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        gasLimit: GAS_LIMITS.NATIVE_TRANSFER,
+    });
+    signedTxs.push(profitTx);
+    return { signedTransactions: signedTxs, hopWallets };
+}

package/dist/chains/eni/batch-router/transfer-shared.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ENI BatchRouter — 批量转账共享常量
+ *
+ * 供 transfer-disperse / transfer-sweep 共享使用，不作为公共 API 导出。
+ */
+import { Interface } from 'ethers';
+export declare const erc20Iface: Interface;
+export declare const DEFAULT_GAS_PER_SWEEP = 200000n;
+export declare const GAS_NATIVE_TRANSFER = 21000n;

package/dist/chains/eni/batch-router/transfer-shared.js

@@ -0,0 +1,10 @@
+/**
+ * ENI BatchRouter — 批量转账共享常量
+ *
+ * 供 transfer-disperse / transfer-sweep 共享使用，不作为公共 API 导出。
+ */
+import { Interface } from 'ethers';
+import { ERC20_ABI } from '../../../abis/common.js';
+export const erc20Iface = new Interface(ERC20_ABI);
+export const DEFAULT_GAS_PER_SWEEP = 200000n;
+export const GAS_NATIVE_TRANSFER = 21000n;

package/dist/chains/eni/batch-router/transfer-sweep.d.ts

@@ -0,0 +1,51 @@
+/**
+ * ENI BatchRouter — 批量归集（EGAS / ERC20）
+ *
+ * - batchSweepToken: 批量归集 ERC20 (各钱包独立签名)
+ * - batchSweepEgas: 批量归集 EGAS (各钱包独立签名)
+ * - eniSweepForSubmit: 前端统一入口 (EGAS / ERC20 归集)
+ */
+export interface BatchSweepTokenParams {
+    rpcUrl?: string;
+    token: string;
+    privateKeys: string[];
+    amounts: bigint[];
+    target: string;
+    gasPrice?: bigint;
+    gasLimit?: bigint;
+}
+export interface BatchSweepTokenResult {
+    transactions: Array<{
+        signedTx: string;
+        from: string;
+        nonce: number;
+    }>;
+}
+export declare function batchSweepToken(params: BatchSweepTokenParams): Promise<BatchSweepTokenResult>;
+export interface BatchSweepEgasParams {
+    rpcUrl?: string;
+    privateKeys: string[];
+    amounts: bigint[];
+    target: string;
+    gasPrice?: bigint;
+}
+export declare function batchSweepEgas(params: BatchSweepEgasParams): Promise<BatchSweepTokenResult>;
+export interface EniSweepParams {
+    rpcUrl?: string;
+    sourcePrivateKeys: string[];
+    target: string;
+    targetPrivateKey?: string;
+    tokenAddress?: string;
+    tokenDecimals?: number;
+    ratioPct?: number;
+    hopCount?: number;
+    gasLimit?: number;
+}
+export interface EniSweepResult {
+    signedTransactions: string[];
+    hopWallets?: {
+        address: string;
+        privateKey: string;
+    }[][];
+}
+export declare function eniSweepForSubmit(params: EniSweepParams): Promise<EniSweepResult>;