four-flap-meme-sdk 2.2.19 → 3.0.0

package/dist/bundle/config-helpers.js

@@ -0,0 +1,58 @@
+import { ethers } from 'ethers';
+import { getProfitRateBps as getSharedProfitRateBps, getProfitRecipient as pickRandomProfitRecipient, } from '../core/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/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/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/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/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 '../../core/constants/index.js';
+import { ERC20_ABI } from '../../abis/common.js';
+import { getErrorMessageFromUnknown } from '../../core/index.js';
+import { getTxType, getGasPriceConfig } from '../config-helpers.js';
+import { createSignProvider } from '../sign-context-helpers.js';
+import { batchCheckAllowances } from '../../core/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/four-meme/core-helpers.d.ts

@@ -0,0 +1,8 @@
+import { Wallet } from 'ethers';
+import { FourClient } from '../../core/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/four-meme/core-helpers.js

@@ -0,0 +1,41 @@
+import { Wallet } from 'ethers';
+import { CHAINS } from '../../core/constants/index.js';
+import { buildLoginMessage } from '../../core/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/{contracts/tm-bundle-merkle → bundle/four-meme}/core.d.ts

@@ -1,4 +1,4 @@
-import { FourCreateWithBundleBuySignParams, FourCreateWithBundleBuyMerkleResult, FourBatchBuySignParams, FourBatchBuyMerkleResult, FourBatchSellSignParams, FourBatchSellMerkleResult } from './types.js';
+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>;