four-flap-meme-sdk 2.2.18 → 2.2.20

package/dist/bundle-core/__tests__/sign-fixture.test.js

@@ -0,0 +1,220 @@
+import { ethers } from 'ethers';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { FourClient } from '../../shared/clients/four.js';
+import { disperseWithBundleMerkle } from '../four-meme/utils-disperse.js';
+import { sweepWithBundleMerkle } from '../four-meme/utils-sweep.js';
+import { pairwiseTransferWithBundleMerkle } from '../four-meme/utils-pairwise.js';
+import { fourBundleSwapMerkle } from '../four-meme/swap.js';
+import { createTokenWithBundleBuyMerkle } from '../four-meme/core.js';
+import { disperseWithBundleMerkle as facadeDisperse } from '../../chains/bsc/four/utils-disperse.js';
+import { sweepWithBundleMerkle as facadeSweep } from '../../chains/bsc/four/utils-sweep.js';
+import * as bundleInternal from '../internal.js';
+import * as swapHelpers from '../../utils/swap-helpers.js';
+import { TM_ADDRESS } from '../four-meme/swap-internal.js';
+import { SIGN_FIXTURE_CHAIN_ID, SIGN_FIXTURE_PRIVATE_KEY, SIGN_FIXTURE_RECIPIENT, SIGN_FIXTURE_RPC, mockJsonRpcFeeData, parseSignedTx, } from './sign-fixtures.js';
+const MNEMONIC = 'test test test test test test test test test test test junk';
+describe('bundle-core sign-only fixtures', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('bsc/four utils re-export bundle-core implementations', () => {
+        expect(facadeDisperse).toBe(disperseWithBundleMerkle);
+        expect(facadeSweep).toBe(sweepWithBundleMerkle);
+    });
+    it('disperseWithBundleMerkle returns empty when no recipients', async () => {
+        const result = await disperseWithBundleMerkle({
+            fromPrivateKey: SIGN_FIXTURE_PRIVATE_KEY,
+            recipients: [],
+            amount: '0.01',
+            config: { rpcUrl: SIGN_FIXTURE_RPC, chainId: SIGN_FIXTURE_CHAIN_ID },
+        });
+        expect(result.signedTransactions).toEqual([]);
+    });
+    it('disperseWithBundleMerkle signs native BNB transfer + profit hop (offline)', async () => {
+        mockJsonRpcFeeData('5');
+        const startNonce = 12;
+        const result = await disperseWithBundleMerkle({
+            fromPrivateKey: SIGN_FIXTURE_PRIVATE_KEY,
+            recipients: [SIGN_FIXTURE_RECIPIENT],
+            amount: '0.01',
+            config: {
+                rpcUrl: SIGN_FIXTURE_RPC,
+                chainId: SIGN_FIXTURE_CHAIN_ID,
+                minGasPriceGwei: 5,
+                bribeAmount: 0,
+                prefer21000ForNative: true,
+            },
+            startNonce,
+        });
+        expect(result.signedTransactions.length).toBe(4);
+        const transferTx = parseSignedTx(result.signedTransactions[0]);
+        expect(transferTx.chainId).toBe(BigInt(SIGN_FIXTURE_CHAIN_ID));
+        expect(transferTx.type).toBe(0);
+        expect(transferTx.nonce).toBe(startNonce);
+        expect(transferTx.to?.toLowerCase()).toBe(SIGN_FIXTURE_RECIPIENT.toLowerCase());
+        expect(transferTx.value).toBe(ethers.parseEther('0.01'));
+        for (const signed of result.signedTransactions) {
+            expect(signed.startsWith('0x')).toBe(true);
+            expect(parseSignedTx(signed).chainId).toBe(BigInt(SIGN_FIXTURE_CHAIN_ID));
+        }
+        expect(result.profitHopWallets?.length).toBe(2);
+        expect(result.metadata?.recipientCount).toBe(1);
+        expect(result.metadata?.isNative).toBe(true);
+    });
+    it('sweepWithBundleMerkle signs native sweep with target paying profit (offline)', async () => {
+        mockJsonRpcFeeData('5');
+        vi.spyOn(bundleInternal, 'batchGetBalances').mockResolvedValue([ethers.parseEther('1')]);
+        vi.spyOn(ethers.JsonRpcProvider.prototype, 'getTransactionCount').mockResolvedValue(3);
+        const source = ethers.HDNodeWallet.fromPhrase(MNEMONIC, undefined, "m/44'/60'/0'/0/1");
+        const target = ethers.HDNodeWallet.fromPhrase(MNEMONIC, undefined, "m/44'/60'/0'/0/2");
+        const result = await sweepWithBundleMerkle({
+            sourcePrivateKeys: [source.privateKey],
+            target: target.address,
+            targetPrivateKey: target.privateKey,
+            amount: '0.05',
+            config: {
+                rpcUrl: SIGN_FIXTURE_RPC,
+                chainId: SIGN_FIXTURE_CHAIN_ID,
+                minGasPriceGwei: 5,
+                bribeAmount: 0,
+                prefer21000ForNative: true,
+            },
+        });
+        expect(result.signedTransactions.length).toBeGreaterThanOrEqual(2);
+        const sweepTx = result.signedTransactions.find((raw) => {
+            const tx = parseSignedTx(raw);
+            return tx.to?.toLowerCase() === target.address.toLowerCase() && tx.value === ethers.parseEther('0.05');
+        });
+        expect(sweepTx).toBeDefined();
+        expect(result.metadata?.isNative).toBe(true);
+    });
+    it('pairwiseTransferWithBundleMerkle signs native pairwise transfer (offline)', async () => {
+        mockJsonRpcFeeData('5');
+        const sender = ethers.HDNodeWallet.fromPhrase(MNEMONIC, undefined, "m/44'/60'/0'/0/3");
+        const receiver = ethers.HDNodeWallet.fromPhrase(MNEMONIC, undefined, "m/44'/60'/0'/0/4");
+        const result = await pairwiseTransferWithBundleMerkle({
+            senderPrivateKeys: [sender.privateKey],
+            receiverAddresses: [receiver.address],
+            amount: '0.02',
+            config: {
+                rpcUrl: SIGN_FIXTURE_RPC,
+                chainId: SIGN_FIXTURE_CHAIN_ID,
+                minGasPriceGwei: 5,
+                bribeAmount: 0,
+                prefer21000ForNative: true,
+            },
+            startNonce: 7,
+        });
+        expect(result.signedTransactions.length).toBeGreaterThanOrEqual(1);
+        const transferTx = result.signedTransactions.find((raw) => {
+            const tx = parseSignedTx(raw);
+            return tx.to?.toLowerCase() === receiver.address.toLowerCase() && tx.value === ethers.parseEther('0.02');
+        });
+        expect(transferTx).toBeDefined();
+        expect(result.metadata?.pairCount).toBe(1);
+        expect(result.metadata?.isNative).toBe(true);
+    });
+    it('fourBundleSwapMerkle signs sell+buy bundle (offline)', async () => {
+        mockJsonRpcFeeData('5');
+        vi.spyOn(swapHelpers, 'calculateSellAmount').mockResolvedValue({
+            amount: ethers.parseUnits('1000', 18),
+            decimals: 18,
+        });
+        const sellQuoteFunds = ethers.parseEther('0.5');
+        vi.spyOn(ethers.JsonRpcProvider.prototype, 'getBalance').mockResolvedValue(ethers.parseEther('10'));
+        vi.spyOn(ethers.Contract.prototype, 'getFunction').mockImplementation(((name) => {
+            if (name === 'trySell') {
+                return async () => ({ funds: sellQuoteFunds });
+            }
+            if (name === 'allowance') {
+                return async () => ethers.MaxUint256;
+            }
+            if (name === 'sellToken') {
+                return {
+                    populateTransaction: async () => ({
+                        to: TM_ADDRESS,
+                        data: '0xdeadbeef',
+                    }),
+                };
+            }
+            if (name === 'buyTokenAMAP') {
+                return {
+                    populateTransaction: async () => ({
+                        to: TM_ADDRESS,
+                        data: '0xcafebabe',
+                    }),
+                };
+            }
+            return async () => {
+                throw new Error(`unexpected getFunction ${name}`);
+            };
+        }));
+        const seller = ethers.HDNodeWallet.fromPhrase(MNEMONIC, undefined, "m/44'/60'/0'/0/5");
+        const buyer = ethers.HDNodeWallet.fromPhrase(MNEMONIC, undefined, "m/44'/60'/0'/0/6");
+        const tokenAddress = '0x1111111111111111111111111111111111111111';
+        const result = await fourBundleSwapMerkle({
+            sellerPrivateKey: seller.privateKey,
+            buyerPrivateKey: buyer.privateKey,
+            sellAmount: '1000',
+            tokenAddress,
+            config: {
+                rpcUrl: SIGN_FIXTURE_RPC,
+                chainId: SIGN_FIXTURE_CHAIN_ID,
+                minGasPriceGwei: 5,
+                bribeAmount: 0,
+            },
+            startNonces: [3, 1],
+        });
+        expect(result.signedTransactions.length).toBeGreaterThanOrEqual(2);
+        for (const signed of result.signedTransactions) {
+            expect(parseSignedTx(signed).chainId).toBe(BigInt(SIGN_FIXTURE_CHAIN_ID));
+        }
+        expect(result.metadata?.sellerAddress.toLowerCase()).toBe(seller.address.toLowerCase());
+        expect(result.metadata?.buyerAddress.toLowerCase()).toBe(buyer.address.toLowerCase());
+    });
+    it('createTokenWithBundleBuyMerkle signs create bundle with mocked Four API (offline)', async () => {
+        mockJsonRpcFeeData('5');
+        vi.spyOn(ethers.JsonRpcProvider.prototype, 'getTransactionCount').mockResolvedValue(7);
+        vi.spyOn(FourClient.prototype, 'generateNonce').mockResolvedValue('fixture-nonce');
+        vi.spyOn(FourClient.prototype, 'loginDex').mockResolvedValue('fixture-token');
+        vi.spyOn(FourClient.prototype, 'createToken').mockResolvedValue({
+            createArg: '0xabcd',
+            signature: '0x1234',
+        });
+        const originalGetFunction = ethers.Contract.prototype.getFunction;
+        vi.spyOn(ethers.Contract.prototype, 'getFunction').mockImplementation(function (key) {
+            const name = typeof key === 'string' ? key : key.name;
+            if (name === 'createToken') {
+                return Object.assign(async () => ({}), {
+                    populateTransaction: async () => ({
+                        to: '0x5c952063c7fc8610FFDB798152D69F0B9550762b',
+                        data: '0xdeadbeef',
+                    }),
+                });
+            }
+            return originalGetFunction.call(this, key);
+        });
+        const result = await createTokenWithBundleBuyMerkle({
+            privateKeys: [SIGN_FIXTURE_PRIVATE_KEY],
+            buyAmounts: ['0.01'],
+            tokenInfo: {
+                name: 'Fixture',
+                symbol: 'FIX',
+                description: 'fixture',
+                imageUrl: 'https://example.com/fix.png',
+                preSale: '0.01',
+            },
+            config: {
+                rpcUrl: SIGN_FIXTURE_RPC,
+                chainId: SIGN_FIXTURE_CHAIN_ID,
+                minGasPriceGwei: 5,
+                bribeAmount: 0,
+            },
+        });
+        expect(result.signedTransactions.length).toBeGreaterThanOrEqual(1);
+        for (const signed of result.signedTransactions) {
+            expect(parseSignedTx(signed).chainId).toBe(BigInt(SIGN_FIXTURE_CHAIN_ID));
+        }
+        expect(result.tokenAddress).toBe('0x0000000000000000000000000000000000000000');
+    });
+});

package/dist/bundle-core/__tests__/sign-fixtures.d.ts

@@ -0,0 +1,10 @@
+import { ethers } from 'ethers';
+/** Hardhat / Anvil mnemonic #0 — 仅用于离线 sign fixture */
+export declare const SIGN_FIXTURE_WALLET: ethers.HDNodeWallet;
+export declare const SIGN_FIXTURE_PRIVATE_KEY: string;
+/** Hardhat / Anvil mnemonic #1 */
+export declare const SIGN_FIXTURE_RECIPIENT = "0x70997970C51812dc3A010C7d01b50e0d17dc79C8";
+export declare const SIGN_FIXTURE_RPC = "http://127.0.0.1:8545";
+export declare const SIGN_FIXTURE_CHAIN_ID = 56;
+export declare function mockJsonRpcFeeData(gasPriceGwei?: string): any;
+export declare function parseSignedTx(signed: string): ethers.Transaction;

package/dist/bundle-core/__tests__/sign-fixtures.js

@@ -0,0 +1,16 @@
+import { ethers } from 'ethers';
+import { vi } from 'vitest';
+/** Hardhat / Anvil mnemonic #0 — 仅用于离线 sign fixture */
+export const SIGN_FIXTURE_WALLET = ethers.Wallet.fromPhrase('test test test test test test test test test test test junk');
+export const SIGN_FIXTURE_PRIVATE_KEY = SIGN_FIXTURE_WALLET.privateKey;
+/** Hardhat / Anvil mnemonic #1 */
+export const SIGN_FIXTURE_RECIPIENT = '0x70997970C51812dc3A010C7d01b50e0d17dc79C8';
+export const SIGN_FIXTURE_RPC = 'http://127.0.0.1:8545';
+export const SIGN_FIXTURE_CHAIN_ID = 56;
+export function mockJsonRpcFeeData(gasPriceGwei = '3') {
+    const feeData = new ethers.FeeData(ethers.parseUnits(gasPriceGwei, 'gwei'), null, null);
+    return vi.spyOn(ethers.JsonRpcProvider.prototype, 'getFeeData').mockResolvedValue(feeData);
+}
+export function parseSignedTx(signed) {
+    return ethers.Transaction.from(signed);
+}

package/dist/bundle-core/config-helpers.d.ts

@@ -0,0 +1,37 @@
+import type { GasPriceConfig } from '../shared/foundation/gas/bundle-gas.js';
+/** Gas / Tx 相关配置（各 bundle 模块 config 的公共字段） */
+export type BundleGasConfigInput = {
+    txType?: 0 | 2;
+    gasPriceMultiplierPercent?: number;
+    minGasPriceGwei?: number;
+};
+/** Merkle bundle 提交相关配置 */
+export type BundleMerkleConfigInput = BundleGasConfigInput & {
+    bundleBlockOffset?: number;
+    minBlockOffset?: number;
+    autoRetryBundle?: boolean;
+    maxBundleRetries?: number;
+    bribeAmount?: number;
+};
+export declare function getTxType(config: BundleGasConfigInput): 0 | 2;
+export declare function getGasPriceMultiplier(config: BundleGasConfigInput): number;
+export type BundleSubmitOptions = {
+    blockOffset: number;
+    minBlockOffset: number;
+    autoRetry: boolean;
+    maxRetries: number;
+};
+export declare function getBundleOptions(config: BundleMerkleConfigInput, blockOffset?: number): BundleSubmitOptions;
+export declare function getGasPriceConfig(config: BundleGasConfigInput): GasPriceConfig;
+export declare function shouldExtractProfit(_config?: BundleMerkleConfigInput): boolean;
+export declare function getProfitRateBps(_config?: BundleMerkleConfigInput): number;
+export declare function getProfitRecipient(_config?: BundleMerkleConfigInput): string;
+export declare function calculateProfit(amount: bigint, _config?: BundleMerkleConfigInput): {
+    profit: bigint;
+    remaining: bigint;
+};
+export declare function calculateBatchProfit(amounts: bigint[], _config?: BundleMerkleConfigInput): {
+    totalProfit: bigint;
+    remainingAmounts: bigint[];
+};
+export declare function getBribeAmount(config?: BundleMerkleConfigInput): bigint;

package/dist/bundle-core/config-helpers.js

@@ -0,0 +1,58 @@
+import { ethers } from 'ethers';
+import { getProfitRateBps as getSharedProfitRateBps, getProfitRecipient as pickRandomProfitRecipient, } from '../shared/constants/index.js';
+export function getTxType(config) {
+    return config.txType ?? 0;
+}
+export function getGasPriceMultiplier(config) {
+    const value = config.gasPriceMultiplierPercent;
+    return typeof value === 'number' && Number.isFinite(value) ? value : 50;
+}
+export function getBundleOptions(config, blockOffset) {
+    return {
+        blockOffset: blockOffset ?? config.bundleBlockOffset ?? 3,
+        minBlockOffset: config.minBlockOffset ?? 3,
+        autoRetry: config.autoRetryBundle ?? false,
+        maxRetries: config.maxBundleRetries ?? 2,
+    };
+}
+export function getGasPriceConfig(config) {
+    const gasPriceConfig = {};
+    if (config.minGasPriceGwei !== undefined) {
+        gasPriceConfig.baseGasPrice = ethers.parseUnits(String(config.minGasPriceGwei), 'gwei');
+        gasPriceConfig.multiplierPercent = 0;
+    }
+    else {
+        gasPriceConfig.multiplierPercent = getGasPriceMultiplier(config);
+    }
+    return gasPriceConfig;
+}
+export function shouldExtractProfit(_config) {
+    return true;
+}
+export function getProfitRateBps(_config) {
+    return getSharedProfitRateBps('normal');
+}
+export function getProfitRecipient(_config) {
+    return pickRandomProfitRecipient();
+}
+export function calculateProfit(amount, _config) {
+    const profit = (amount * BigInt(getProfitRateBps())) / 10000n;
+    return { profit, remaining: amount - profit };
+}
+export function calculateBatchProfit(amounts, _config) {
+    let totalProfit = 0n;
+    const remainingAmounts = [];
+    for (const amount of amounts) {
+        const { profit, remaining } = calculateProfit(amount);
+        totalProfit += profit;
+        remainingAmounts.push(remaining);
+    }
+    return { totalProfit, remainingAmounts };
+}
+export function getBribeAmount(config) {
+    const bribeBnB = config && typeof config.bribeAmount === 'number' ? config.bribeAmount : undefined;
+    if (bribeBnB === undefined || !Number.isFinite(bribeBnB) || bribeBnB <= 0) {
+        return 0n;
+    }
+    return ethers.parseEther(String(bribeBnB));
+}

package/dist/bundle-core/errors.d.ts

@@ -0,0 +1,50 @@
+export declare const BUNDLE_ERRORS: {
+    readonly NO_PRIVATE_KEY: {
+        readonly en: "At least 1 private key (creator) is required";
+        readonly zh: "至少需要 1 个私钥（创建者）";
+    };
+    readonly AMOUNT_MISMATCH: {
+        readonly en: (buyCount: number, buyerCount: number) => string;
+        readonly zh: (buyCount: number, buyerCount: number) => string;
+    };
+    readonly IMAGE_REQUIRED: {
+        readonly en: "Either imageUrl or imageFile must be provided";
+        readonly zh: "必须提供 imageUrl 或 imageFile";
+    };
+    readonly KEY_AMOUNT_MISMATCH: {
+        readonly en: "Private key count and amount count must match";
+        readonly zh: "私钥和购买金额数量必须一致";
+    };
+    readonly SELL_KEY_AMOUNT_MISMATCH: {
+        readonly en: "Private key count and sell amount count must match";
+        readonly zh: "私钥和卖出数量必须一致";
+    };
+};
+/** @deprecated 使用 BUNDLE_ERRORS */
+export declare const ERRORS: {
+    readonly NO_PRIVATE_KEY: {
+        readonly en: "At least 1 private key (creator) is required";
+        readonly zh: "至少需要 1 个私钥（创建者）";
+    };
+    readonly AMOUNT_MISMATCH: {
+        readonly en: (buyCount: number, buyerCount: number) => string;
+        readonly zh: (buyCount: number, buyerCount: number) => string;
+    };
+    readonly IMAGE_REQUIRED: {
+        readonly en: "Either imageUrl or imageFile must be provided";
+        readonly zh: "必须提供 imageUrl 或 imageFile";
+    };
+    readonly KEY_AMOUNT_MISMATCH: {
+        readonly en: "Private key count and amount count must match";
+        readonly zh: "私钥和购买金额数量必须一致";
+    };
+    readonly SELL_KEY_AMOUNT_MISMATCH: {
+        readonly en: "Private key count and sell amount count must match";
+        readonly zh: "私钥和卖出数量必须一致";
+    };
+};
+type ErrorArgs<K extends keyof typeof BUNDLE_ERRORS> = (typeof BUNDLE_ERRORS)[K]['en'] extends (...args: infer P) => string ? P : [];
+export declare function getBundleErrorMessage<K extends keyof typeof BUNDLE_ERRORS>(key: K, ...args: ErrorArgs<K>): string;
+/** @deprecated 使用 getBundleErrorMessage */
+export declare const getErrorMessage: typeof getBundleErrorMessage;
+export {};

package/dist/bundle-core/errors.js

@@ -0,0 +1,38 @@
+export const BUNDLE_ERRORS = {
+    NO_PRIVATE_KEY: {
+        en: 'At least 1 private key (creator) is required',
+        zh: '至少需要 1 个私钥（创建者）',
+    },
+    AMOUNT_MISMATCH: {
+        en: (buyCount, buyerCount) => `Buy amount count (${buyCount}) must equal buyer count (${buyerCount})`,
+        zh: (buyCount, buyerCount) => `购买金额数量(${buyCount})必须等于买家数量(${buyerCount})`,
+    },
+    IMAGE_REQUIRED: {
+        en: 'Either imageUrl or imageFile must be provided',
+        zh: '必须提供 imageUrl 或 imageFile',
+    },
+    KEY_AMOUNT_MISMATCH: {
+        en: 'Private key count and amount count must match',
+        zh: '私钥和购买金额数量必须一致',
+    },
+    SELL_KEY_AMOUNT_MISMATCH: {
+        en: 'Private key count and sell amount count must match',
+        zh: '私钥和卖出数量必须一致',
+    },
+};
+/** @deprecated 使用 BUNDLE_ERRORS */
+export const ERRORS = BUNDLE_ERRORS;
+export function getBundleErrorMessage(key, ...args) {
+    const langSource = (typeof process !== 'undefined' && process.env && (process.env.LANG || process.env.LANGUAGE)) ||
+        (typeof navigator !== 'undefined' && navigator.language) ||
+        'en';
+    const lang = langSource.toLowerCase().includes('zh') ? 'zh' : 'en';
+    const message = BUNDLE_ERRORS[key][lang];
+    if (typeof message === 'function') {
+        const [a, b] = args;
+        return message(a, b);
+    }
+    return message;
+}
+/** @deprecated 使用 getBundleErrorMessage */
+export const getErrorMessage = getBundleErrorMessage;

package/dist/bundle-core/four-meme/approve-tokenmanager.d.ts

@@ -0,0 +1,7 @@
+import type { ApproveFourTokenManagerBatchParams, ApproveFourTokenManagerBatchResult } from './types.js';
+export type { ApproveFourTokenManagerBatchParams, ApproveFourTokenManagerBatchResult } from './types.js';
+/**
+ * 批量授权代币给 TokenManager（用于 Private Buy/Sell）
+ * ✅ 直接通过 RPC 提交到链上并等待确认
+ */
+export declare function approveFourTokenManagerBatch(params: ApproveFourTokenManagerBatchParams): Promise<ApproveFourTokenManagerBatchResult>;

package/dist/bundle-core/four-meme/approve-tokenmanager.js

@@ -0,0 +1,99 @@
+import { ethers, Wallet } from 'ethers';
+import { NonceManager, getOptimizedGasPrice } from '../../utils/bundle-helpers.js';
+import { ADDRESSES, CHAINS } from '../../shared/constants/index.js';
+import { ERC20_ABI } from '../../abis/common.js';
+import { getErrorMessageFromUnknown } from '../../shared/foundation/index.js';
+import { getTxType, getGasPriceConfig } from '../config-helpers.js';
+import { createSignProvider } from '../sign-context-helpers.js';
+import { batchCheckAllowances } from '../../utils/erc20.js';
+const APPROVAL_THRESHOLD = ethers.MaxUint256 / 2n;
+function resolveApprovalGasLimit(config) {
+    if (config.gasLimit)
+        return BigInt(config.gasLimit);
+    if (config.gasLimitMultiplier)
+        return BigInt(Math.ceil(60000 * config.gasLimitMultiplier));
+    return 60000n;
+}
+/**
+ * 批量授权代币给 TokenManager（用于 Private Buy/Sell）
+ * ✅ 直接通过 RPC 提交到链上并等待确认
+ */
+export async function approveFourTokenManagerBatch(params) {
+    const { privateKeys, tokenAddress, amounts, config } = params;
+    if (privateKeys.length === 0 || amounts.length !== privateKeys.length) {
+        throw new Error('Private key count and amount count must match');
+    }
+    const tmAddr = ADDRESSES.BSC.TokenManagerOriginal;
+    const chainId = config.chainId ?? CHAINS.BSC.chainId;
+    const provider = createSignProvider(config.rpcUrl, chainId);
+    const wallets = privateKeys.map((k) => new Wallet(k, provider));
+    const allMax = amounts.every((a) => a === 'max');
+    const [gasPrice, decimals, allowances] = await Promise.all([
+        getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+        allMax
+            ? Promise.resolve(18)
+            : (async () => {
+                try {
+                    const tokenContract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
+                    return await tokenContract.decimals();
+                }
+                catch (error) {
+                    throw new Error(`查询代币 decimals 失败: ${getErrorMessageFromUnknown(error)}`);
+                }
+            })(),
+        batchCheckAllowances(provider, tokenAddress, wallets.map((w) => w.address), tmAddr),
+    ]);
+    const amountsBigInt = amounts.map((a) => (a === 'max' ? ethers.MaxUint256 : ethers.parseUnits(a, decimals)));
+    const needApproval = wallets.filter((_, i) => allowances[i] < APPROVAL_THRESHOLD);
+    const needApprovalAmounts = amountsBigInt.filter((_, i) => allowances[i] < APPROVAL_THRESHOLD);
+    const skippedCount = wallets.length - needApproval.length;
+    if (needApproval.length === 0) {
+        return {
+            success: true,
+            signedTransactions: [],
+            approvedCount: 0,
+            skippedCount,
+            message: '所有钱包已授权，无需重复授权',
+        };
+    }
+    const finalGasLimit = resolveApprovalGasLimit(config);
+    const txType = getTxType(config);
+    const nonceManager = new NonceManager(provider);
+    const needApprovalTokens = needApproval.map((w) => new ethers.Contract(tokenAddress, ERC20_ABI, w));
+    const [nonces, unsignedApprovals] = await Promise.all([
+        nonceManager.getNextNoncesForWallets(needApproval),
+        Promise.all(needApprovalTokens.map((token, i) => token.approve.populateTransaction(tmAddr, needApprovalAmounts[i]))),
+    ]);
+    const signedTxs = await Promise.all(unsignedApprovals.map((unsigned, i) => needApproval[i].signTransaction({
+        ...unsigned,
+        from: needApproval[i].address,
+        nonce: nonces[i],
+        gasLimit: finalGasLimit,
+        gasPrice,
+        chainId,
+        type: txType,
+    })));
+    nonceManager.clearTemp();
+    try {
+        const txResponses = await Promise.all(signedTxs.map((tx) => provider.broadcastTransaction(tx)));
+        const txHashes = txResponses.map((r) => r.hash);
+        await Promise.all(txResponses.map((tx) => tx.wait(1)));
+        return {
+            success: true,
+            signedTransactions: signedTxs,
+            approvedCount: signedTxs.length,
+            skippedCount,
+            txHashes,
+            message: `授权成功！共 ${signedTxs.length} 个钱包已授权，跳过 ${skippedCount} 个已授权钱包`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            signedTransactions: signedTxs,
+            approvedCount: 0,
+            skippedCount,
+            message: `授权提交失败: ${getErrorMessageFromUnknown(error)}`,
+        };
+    }
+}

package/dist/bundle-core/four-meme/core-helpers.d.ts

@@ -0,0 +1,8 @@
+import { Wallet } from 'ethers';
+import { FourClient } from '../../shared/clients/four.js';
+import type { ChainContext, FourCreateTokenInfo } from './types/core-flow.js';
+export declare const CORE_CHAIN_ID: 56;
+export declare function createChainContext(rpcUrl: string): ChainContext;
+export declare function createWallets(privateKeys: string[], provider: ChainContext['provider']): Wallet[];
+export declare function loginFourClient(wallet: Wallet, fourClient: FourClient): Promise<string>;
+export declare function resolveTokenImage(fourClient: FourClient, tokenInfo: FourCreateTokenInfo, accessToken: string): Promise<string>;

package/dist/bundle-core/four-meme/core-helpers.js

@@ -0,0 +1,41 @@
+import { Wallet } from 'ethers';
+import { CHAINS } from '../../shared/constants/index.js';
+import { buildLoginMessage } from '../../shared/clients/four.js';
+import { createSignProvider } from '../sign-context-helpers.js';
+import { getBundleErrorMessage } from '../errors.js';
+export const CORE_CHAIN_ID = CHAINS.BSC.chainId;
+export function createChainContext(rpcUrl) {
+    const provider = createSignProvider(rpcUrl, CORE_CHAIN_ID, 'BSC');
+    return { provider, chainId: CORE_CHAIN_ID };
+}
+export function createWallets(privateKeys, provider) {
+    return privateKeys.map((key) => new Wallet(key, provider));
+}
+export async function loginFourClient(wallet, fourClient) {
+    const nonce = await fourClient.generateNonce({
+        accountAddress: wallet.address,
+        verifyType: 'LOGIN',
+        networkCode: 'BSC',
+    });
+    const loginSignature = await wallet.signMessage(buildLoginMessage(nonce));
+    return fourClient.loginDex({
+        region: 'WEB',
+        langType: 'EN',
+        verifyInfo: {
+            address: wallet.address,
+            networkCode: 'BSC',
+            signature: loginSignature,
+            verifyType: 'LOGIN',
+        },
+        walletName: 'MetaMask',
+    });
+}
+export async function resolveTokenImage(fourClient, tokenInfo, accessToken) {
+    if (tokenInfo.imageUrl) {
+        return tokenInfo.imageUrl;
+    }
+    if (tokenInfo.imageFile) {
+        return fourClient.uploadImage(accessToken, tokenInfo.imageFile);
+    }
+    throw new Error(getBundleErrorMessage('IMAGE_REQUIRED'));
+}

package/dist/bundle-core/four-meme/core.d.ts

@@ -0,0 +1,4 @@
+import type { FourCreateWithBundleBuySignParams, FourCreateWithBundleBuyMerkleResult, FourBatchBuySignParams, FourBatchBuyMerkleResult, FourBatchSellSignParams, FourBatchSellMerkleResult } from './types.js';
+export declare function createTokenWithBundleBuyMerkle(params: FourCreateWithBundleBuySignParams): Promise<FourCreateWithBundleBuyMerkleResult>;
+export declare function batchBuyWithBundleMerkle(params: FourBatchBuySignParams): Promise<FourBatchBuyMerkleResult>;
+export declare function batchSellWithBundleMerkle(params: FourBatchSellSignParams): Promise<FourBatchSellMerkleResult>;