four-flap-meme-sdk 1.1.99 → 1.2.2

package/dist/contracts/tm-bundle-merkle/core.js

@@ -5,6 +5,7 @@ import { ADDRESSES } from '../../utils/constants.js';
 import { FourClient, buildLoginMessage } from '../../clients/four.js';
 import { getErrorMessage, getTxType, getGasPriceConfig, shouldExtractProfit, calculateProfit } from './config.js';
 import { batchCheckAllowances } from '../../utils/erc20.js';
+import { trySell } from '../tm.js';
 // ==================== TokenManager2 ABI（仅需要的方法）====================
 const TM2_ABI = [
     'function createToken(bytes args, bytes signature) payable',
@@ -322,28 +323,35 @@ export async function batchSellWithBundleMerkle(params) {
     const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
     const sellers = privateKeys.map((k) => new Wallet(k, provider));
     const amountsWei = sellAmounts.map((a) => ethers.parseUnits(a, 18));
-    // ⚠️ Four.meme 内盘代币通过 TokenManager bonding curve 定价，不在 PancakeSwap 上
-    // ✅ 使用用户提供的 minOutputAmounts，或默认为 0（不限制最小输出）
+    // ⚠️ Four.meme 内盘代币通过 TokenManager bonding curve 定价
+    // ✅ 优先使用用户提供的 minOutputAmounts，否则自动调用 trySell 获取
     let minOuts;
     let quotedOutputs = [];
     if (minOutputAmounts && minOutputAmounts.length === sellers.length) {
-        // 用户提供了 minOutputAmounts，优先使用
+        // 用户提供了 minOutputAmounts，用于滑点保护和利润计算
         minOuts = minOutputAmounts.map(m => typeof m === 'string' ? ethers.parseEther(m) : m);
-        quotedOutputs = minOuts.map(m => m * 100n / 95n); // 反推报价（用于利润计算）
-        console.log(`📝 使用用户提供的 minOutputAmounts`);
-        console.log(`💰 minOutputAmounts:`);
-        minOuts.forEach((minOut, i) => {
-            console.log(`   钱包 ${i}: ${ethers.formatEther(minOut)} BNB`);
-        });
+        quotedOutputs = minOuts.map(m => m * 100n / 95n);
     }
     else {
-        // Four.meme 内盘代币：默认 minOutputAmount = 0（不限制），不提取利润
-        minOuts = new Array(sellers.length).fill(0n);
-        quotedOutputs = new Array(sellers.length).fill(0n);
-        console.log(`📝 Four.meme 内盘代币：minOutputAmount = 0（不限制最小输出）`);
-        console.log(`⚠️  无法自动计算卖出收益，建议手动传入 minOutputAmounts 以提取利润`);
+        // ✅ 自动调用 trySell 获取每个钱包的预期收益
+        console.log('💰 自动获取卖出报价...');
+        const rpcUrl = config.customRpcUrl;
+        quotedOutputs = await Promise.all(amountsWei.map(async (amount, i) => {
+            try {
+                const result = await trySell('BSC', rpcUrl, tokenAddress, amount);
+                const quoted = result.funds; // 预期收益
+                console.log(`   钱包 ${i}: 卖出 ${ethers.formatUnits(amount, 18)} 代币 → 预期收益 ${ethers.formatEther(quoted)} BNB`);
+                return quoted;
+            }
+            catch (error) {
+                console.log(`   ⚠️ 钱包 ${i}: 报价失败，使用 minOut = 0`);
+                return 0n;
+            }
+        }));
+        // minOuts 设为预期收益的 95%（作为滑点保护）
+        minOuts = quotedOutputs.map(q => q * 95n / 100n);
+        console.log('');
     }
-    console.log('');
     // ✅ Step 1: 检查代币余额和授权状态
     const ERC20_ABI = [
         'function approve(address spender, uint256 amount) returns (bool)',
@@ -351,60 +359,29 @@ export async function batchSellWithBundleMerkle(params) {
         'function balanceOf(address owner) view returns (uint256)'
     ];
     // 检查代币余额
-    console.log('🔍 检查代币余额...');
     const tokenContract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
     const balances = await Promise.all(sellers.map(w => tokenContract.balanceOf(w.address)));
     for (let i = 0; i < sellers.length; i++) {
-        const balance = balances[i];
-        const sellAmount = amountsWei[i];
-        const balanceFormatted = ethers.formatUnits(balance, 18);
-        const sellAmountFormatted = ethers.formatUnits(sellAmount, 18);
-        console.log(`   钱包 ${i} (${sellers[i].address.slice(0, 6)}...${sellers[i].address.slice(-4)}):`);
-        console.log(`      代币余额: ${balanceFormatted}`);
-        console.log(`      卖出数量: ${sellAmountFormatted}`);
-        if (balance < sellAmount) {
-            throw new Error(`钱包 ${i} (${sellers[i].address}) 代币余额不足\n` +
-                `需要: ${sellAmountFormatted}\n` +
-                `实际: ${balanceFormatted}`);
+        if (balances[i] < amountsWei[i]) {
+            throw new Error(`钱包 ${i} 代币余额不足：` +
+                `需要 ${ethers.formatUnits(amountsWei[i], 18)}，` +
+                `实际 ${ethers.formatUnits(balances[i], 18)}`);
         }
     }
-    console.log('\n🔍 使用 Multicall3 批量检查授权状态...');
     const allowances = await batchCheckAllowances(provider, tokenAddress, sellers.map(w => w.address), tmAddr);
     // 找出需要授权的钱包索引
     // ✅ 检查授权额度是否足够卖出
     const needApprovalIndexes = [];
     for (let i = 0; i < sellers.length; i++) {
-        const allowance = allowances[i];
-        const sellAmount = amountsWei[i];
-        const allowanceFormatted = allowance === ethers.MaxUint256 ? 'MAX (无限)' : ethers.formatUnits(allowance, 18);
-        const sellAmountFormatted = ethers.formatUnits(sellAmount, 18);
-        console.log(`   钱包 ${i}:`);
-        console.log(`      当前授权: ${allowanceFormatted}`);
-        console.log(`      需要授权: ${sellAmountFormatted}`);
-        // ✅ 检查授权额度是否 >= 卖出数量
-        if (allowance < sellAmount) {
+        if (allowances[i] < amountsWei[i]) {
             needApprovalIndexes.push(i);
-            console.log(`      ❌ 授权不足！`);
-        }
-        else {
-            console.log(`      ✅ 授权充足`);
         }
     }
-    console.log(`\n   📊 授权统计:`);
-    console.log(`      总钱包数: ${sellers.length}`);
-    console.log(`      需要授权: ${needApprovalIndexes.length}`);
-    console.log(`      已有授权: ${sellers.length - needApprovalIndexes.length}\n`);
-    // ✅ Step 2: 批量授权（如果需要）
-    // ⚠️ 注意：授权需要单独提交，SDK只返回签名交易
+    // ✅ Step 2: 检查授权
     if (needApprovalIndexes.length > 0) {
-        console.log(`⚠️ 警告：检测到 ${needApprovalIndexes.length} 个钱包需要授权`);
-        console.log('   请先使用 approveFourTokenManagerBatch 方法授权');
-        console.log('   ⚠️  重要：请使用 amounts: ["max", "max", ...] 授权，避免重复授权');
-        throw new Error(`需要授权: ${needApprovalIndexes.length} 个钱包授权额度不足。\n` +
-            `解决方案：调用 approveFourTokenManagerBatch({ amounts: ['max', 'max', ...] })`);
+        throw new Error(`${needApprovalIndexes.length} 个钱包需要授权。` +
+            `请先调用 approveFourTokenManagerBatch({ amounts: ['max', ...] })`);
     }
-    // ✅ Step 3: 批量卖出
-    console.log('💰 提交卖出交易...');
     const nonceManager = new NonceManager(provider);
     const signedTxs = [];
     const tm2Contracts = sellers.map((w) => new ethers.Contract(tmAddr, TM2_ABI, w));
@@ -423,17 +400,13 @@ export async function batchSellWithBundleMerkle(params) {
         type: getTxType(config)
     })));
     signedTxs.push(...signedList);
-    // ✅ 基于报价金额为每个钱包添加利润转账
+    // ✅ 提取利润
     const extractProfit = shouldExtractProfit(config);
     if (extractProfit && quotedOutputs.length > 0) {
-        console.log(`💰 提取利润交易...`);
-        let totalProfitExtracted = 0n;
-        // 为每个钱包添加利润转账（基于完整报价金额，而非 minOut）
         for (let i = 0; i < sellers.length; i++) {
-            if (quotedOutputs[i] > 0n) { // 只对报价成功的交易提取利润
+            if (quotedOutputs[i] > 0n) {
                 const { profit } = calculateProfit(quotedOutputs[i], config);
                 if (profit > 0n) {
-                    console.log(`   ✅ 钱包 ${i}: 从 ${ethers.formatEther(quotedOutputs[i])} BNB 中提取 ${ethers.formatEther(profit)} BNB (${config.profitRateBps / 100}%)`);
                     const profitNonce = await nonceManager.getNextNonce(sellers[i]);
                     const profitTx = await sellers[i].signTransaction({
                         to: config.profitRecipient,
@@ -445,11 +418,9 @@ export async function batchSellWithBundleMerkle(params) {
                         type: getTxType(config)
                     });
                     signedTxs.push(profitTx);
-                    totalProfitExtracted += profit;
                 }
             }
         }
-        console.log(`   💵 总利润: ${ethers.formatEther(totalProfitExtracted)} BNB → ${config.profitRecipient}\n`);
     }
     // ✅ 清理临时 nonce 缓存
     nonceManager.clearTemp();

package/dist/contracts/tm-bundle-merkle/private.js

@@ -4,6 +4,7 @@ import { NonceManager, getOptimizedGasPrice } from '../../utils/bundle-helpers.j
 import { ADDRESSES } from '../../utils/constants.js';
 import { getTxType, getGasPriceConfig, shouldExtractProfit, calculateProfit, calculateBatchProfit } from './config.js';
 import { batchCheckAllowances } from '../../utils/erc20.js';
+import { trySell } from '../tm.js';
 // ==================== TokenManager2 ABI（仅需要的方法）====================
 const TM2_ABI = [
     'function buyTokenAMAP(uint256 origin, address token, address to, uint256 funds, uint256 minAmount) payable',
@@ -229,16 +230,6 @@ export async function fourBatchPrivateSellMerkle(params) {
     if (privateKeys.length !== amounts.length) {
         throw new Error('privateKeys and amounts length mismatch');
     }
-    // ⚠️ 友好提示：利润提取需要 minFundsEach
-    if (!minFundsEach && shouldExtractProfit(config)) {
-        console.log('\n⚠️  重要提示：未传入 minFundsEach 参数，将无法提取利润！');
-        console.log('   Four.meme 内盘代币无法自动报价，需要手动估算预期收益');
-        console.log('   建议步骤：');
-        console.log('   1. 在 four.meme 网站查看卖出预期收益');
-        console.log('   2. 传入 minFundsEach 参数');
-        console.log('   示例: minFundsEach: 0.1 (预计每个钱包收到 0.1 BNB)');
-        console.log('   如果只是测试卖出，可以忽略此提示\n');
-    }
     const merkle = new MerkleClient({
         apiKey: config.apiKey,
         chainId: 56,
@@ -248,118 +239,76 @@ export async function fourBatchPrivateSellMerkle(params) {
     const tmAddr = ADDRESSES.BSC.TokenManagerOriginal;
     const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
     const gasMultiplier = config.gasLimitMultiplier ?? 1.0;
-    const minOut = minFundsEach ?? 0n;
     const sellGasLimit = BigInt(Math.ceil(800000 * gasMultiplier));
     const signedTxs = [];
     const nonceManager = new NonceManager(provider);
     const wallets = privateKeys.map((k) => new Wallet(k, provider));
-    // ⚠️ Four.meme 可能对小数精度敏感，建议使用整数
-    const amountsWei = amounts.map((a, idx) => {
-        const amountWei = ethers.parseUnits(a, 18);
-        const hasDecimals = a.includes('.');
-        if (hasDecimals) {
-            console.log(`⚠️  钱包 ${idx}: 检测到小数卖出数量 ${a}`);
-            console.log(`   建议: 使用整数数量（如 42988 而非 42988.04）可能提高成功率`);
-        }
-        return amountWei;
-    });
+    const amountsWei = amounts.map((a) => ethers.parseUnits(a, 18));
+    // ✅ 自动获取每个钱包的预期收益（用于利润计算和滑点保护）
+    let quotedOutputs;
+    let minOuts;
+    if (minFundsEach !== undefined) {
+        // 用户提供了 minFundsEach，所有钱包使用相同的 minOut
+        const minOutWei = typeof minFundsEach === 'string' ? ethers.parseEther(minFundsEach) : minFundsEach;
+        minOuts = new Array(wallets.length).fill(minOutWei);
+        quotedOutputs = minOuts.map(m => m * 100n / 95n);
+    }
+    else {
+        // ✅ 自动调用 trySell 获取每个钱包的预期收益
+        console.log('💰 自动获取卖出报价...');
+        const rpcUrl = config.customRpcUrl;
+        quotedOutputs = await Promise.all(amountsWei.map(async (amount, i) => {
+            try {
+                const result = await trySell('BSC', rpcUrl, tokenAddress, amount);
+                const quoted = result.funds;
+                console.log(`   钱包 ${i}: 卖出 ${ethers.formatUnits(amount, 18)} 代币 → 预期收益 ${ethers.formatEther(quoted)} BNB`);
+                return quoted;
+            }
+            catch (error) {
+                console.log(`   ⚠️ 钱包 ${i}: 报价失败，使用 minOut = 0`);
+                return 0n;
+            }
+        }));
+        // minOuts 设为预期收益的 95%（作为滑点保护）
+        minOuts = quotedOutputs.map(q => q * 95n / 100n);
+        console.log('');
+    }
     // ✅ Step 0: 检查代币余额
-    console.log('🔍 检查代币余额...');
     const tokenContract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
     const balances = await Promise.all(wallets.map(w => tokenContract.balanceOf(w.address)));
     for (let i = 0; i < wallets.length; i++) {
-        const balance = balances[i];
-        const sellAmount = amountsWei[i];
-        const balanceFormatted = ethers.formatUnits(balance, 18);
-        const sellAmountFormatted = ethers.formatUnits(sellAmount, 18);
-        console.log(`   钱包 ${i} (${wallets[i].address.slice(0, 6)}...${wallets[i].address.slice(-4)}):`);
-        console.log(`      代币余额: ${balanceFormatted}`);
-        console.log(`      卖出数量: ${sellAmountFormatted}`);
-        if (balance < sellAmount) {
-            throw new Error(`钱包 ${i} (${wallets[i].address}) 代币余额不足\n` +
-                `需要: ${sellAmountFormatted}\n` +
-                `实际: ${balanceFormatted}`);
+        if (balances[i] < amountsWei[i]) {
+            throw new Error(`钱包 ${i} 代币余额不足：` +
+                `需要 ${ethers.formatUnits(amountsWei[i], 18)}，` +
+                `实际 ${ethers.formatUnits(balances[i], 18)}`);
         }
     }
-    // ✅ Step 1: 使用 Multicall3 批量检查授权状态
-    console.log('\n🔍 使用 Multicall3 批量检查授权状态...');
+    // ✅ Step 1: 检查授权状态
     const allowances = await batchCheckAllowances(provider, tokenAddress, wallets.map(w => w.address), tmAddr);
-    // 找出需要授权的钱包索引
-    // ✅ 检查授权额度是否足够卖出
     const needApprovalIndexes = [];
     for (let i = 0; i < wallets.length; i++) {
-        const allowance = allowances[i];
-        const sellAmount = amountsWei[i];
-        const allowanceFormatted = allowance === ethers.MaxUint256 ? 'MAX (无限)' : ethers.formatUnits(allowance, 18);
-        const sellAmountFormatted = ethers.formatUnits(sellAmount, 18);
-        console.log(`   钱包 ${i}:`);
-        console.log(`      当前授权: ${allowanceFormatted}`);
-        console.log(`      需要授权: ${sellAmountFormatted}`);
-        // ✅ 检查授权额度是否 >= 卖出数量
-        if (allowance < sellAmount) {
+        if (allowances[i] < amountsWei[i]) {
             needApprovalIndexes.push(i);
-            console.log(`      ❌ 授权不足！`);
-        }
-        else {
-            console.log(`      ✅ 授权充足`);
         }
     }
-    console.log(`\n   📊 授权统计:`);
-    console.log(`      总钱包数: ${wallets.length}`);
-    console.log(`      需要授权: ${needApprovalIndexes.length}`);
-    console.log(`      已有授权: ${wallets.length - needApprovalIndexes.length}\n`);
-    // ✅ Step 2: 如果需要授权，抛出错误提示
-    // ⚠️ SDK不再处理授权，需要前端先单独授权
     if (needApprovalIndexes.length > 0) {
-        console.log(`⚠️ 警告：检测到 ${needApprovalIndexes.length} 个钱包需要授权`);
-        console.log('   请先使用 approveFourTokenManagerBatch 方法授权');
-        console.log('   ⚠️  重要：请使用 amounts: ["max", "max", ...] 授权，避免重复授权');
-        throw new Error(`需要授权: ${needApprovalIndexes.length} 个钱包授权额度不足。\n` +
-            `解决方案：调用 approveFourTokenManagerBatch({ amounts: ['max', 'max', ...] })`);
+        throw new Error(`${needApprovalIndexes.length} 个钱包需要授权。` +
+            `请先调用 approveFourTokenManagerBatch({ amounts: ['max', ...] })`);
     }
-    // ✅ Step 3: 检查 BNB 余额（用于支付 gas）
-    console.log('💰 检查 BNB 余额（用于支付 gas 费）...');
+    // ✅ Step 2: 检查 BNB 余额（用于支付 gas）
     const bnbBalances = await Promise.all(wallets.map(w => provider.getBalance(w.address)));
     const estimatedGasCost = sellGasLimit * gasPrice;
     for (let i = 0; i < wallets.length; i++) {
-        const bnbBalance = bnbBalances[i];
-        const bnbFormatted = ethers.formatEther(bnbBalance);
-        const gasFormatted = ethers.formatEther(estimatedGasCost);
-        console.log(`   钱包 ${i}:`);
-        console.log(`      BNB 余额: ${bnbFormatted}`);
-        console.log(`      预计 Gas: ${gasFormatted}`);
-        if (bnbBalance < estimatedGasCost) {
-            console.log(`      ❌ BNB 不足！`);
-            throw new Error(`钱包 ${i} BNB 余额不足支付 gas 费\n` +
-                `需要: ${gasFormatted} BNB\n` +
-                `实际: ${bnbFormatted} BNB\n` +
-                `缺少: ${ethers.formatEther(estimatedGasCost - bnbBalance)} BNB`);
-        }
-        else {
-            const remaining = bnbBalance - estimatedGasCost;
-            console.log(`      ✅ BNB 充足（剩余 ${ethers.formatEther(remaining)}）`);
+        if (bnbBalances[i] < estimatedGasCost) {
+            throw new Error(`钱包 ${i} BNB 不足：` +
+                `需要 ${ethers.formatEther(estimatedGasCost)} BNB，` +
+                `实际 ${ethers.formatEther(bnbBalances[i])} BNB`);
         }
     }
-    // ✅ Step 4: 为每个钱包生成卖出交易
-    console.log('\n💰 构建卖出交易...');
-    console.log(`   TokenManager 合约: ${tmAddr}`);
-    console.log(`   代币地址: ${tokenAddress}`);
-    console.log(`   minFundsEach (最小收益): ${minOut === 0n ? '0 (不限制)' : ethers.formatEther(minOut) + ' BNB'}`);
+    // ✅ Step 3: 构建卖出交易
     const tm2Contracts = wallets.map((w) => new ethers.Contract(tmAddr, TM2_ABI, w));
-    // 显示每个交易的详细参数
-    console.log(`\n   📋 交易参数:`);
-    for (let i = 0; i < wallets.length; i++) {
-        console.log(`   钱包 ${i}:`);
-        console.log(`      卖出数量: ${ethers.formatUnits(amountsWei[i], 18)} 代币`);
-        console.log(`      最小收益: ${minOut === 0n ? '0 BNB (接受任何价格)' : ethers.formatEther(minOut) + ' BNB'}`);
-        console.log(`      合约方法: sellToken(origin=0, token=${tokenAddress.slice(0, 8)}..., amount=${ethers.formatUnits(amountsWei[i], 18)}, minFunds=${minOut})`);
-    }
-    const sellUnsigned = await Promise.all(tm2Contracts.map((c, i) => c.sellToken.populateTransaction(0n, tokenAddress, amountsWei[i], minOut)));
+    const sellUnsigned = await Promise.all(tm2Contracts.map((c, i) => c.sellToken.populateTransaction(0n, tokenAddress, amountsWei[i], minOuts[i])));
     const sellGasLimits = new Array(wallets.length).fill(sellGasLimit);
-    console.log(`\n   ⛽ Gas 设置:`);
-    console.log(`      Gas Limit: ${sellGasLimit}`);
-    console.log(`      Gas Price: ${ethers.formatUnits(gasPrice, 'gwei')} Gwei`);
-    console.log(`      预计 Gas 费: ${ethers.formatEther(sellGasLimit * gasPrice)} BNB (每笔)\n`);
     const sellNonces = await Promise.all(wallets.map((w) => nonceManager.getNextNonce(w)));
     const signedSells = await Promise.all(sellUnsigned.map((unsigned, i) => wallets[i].signTransaction({
         ...unsigned,
@@ -371,42 +320,29 @@ export async function fourBatchPrivateSellMerkle(params) {
         type: getTxType(config)
     })));
     signedTxs.push(...signedSells);
-    console.log(`✅ 已生成 ${signedSells.length} 个卖出交易签名\n`);
-    // ✅ 基于 minFunds 为每个钱包添加利润转账
+    // ✅ 提取利润（基于每个钱包的预期收益）
     const extractProfit = shouldExtractProfit(config);
     if (extractProfit) {
-        if (minOut > 0n) {
-            const { profit } = calculateProfit(minOut, config);
-            if (profit > 0n) {
-                console.log(`💰 提取利润交易...`);
-                console.log(`   每个钱包从 ${ethers.formatEther(minOut)} BNB 中提取 ${ethers.formatEther(profit)} BNB (${config.profitRateBps / 100}%)`);
-                // 为每个钱包添加利润转账
-                const profitNonces = await Promise.all(wallets.map(w => nonceManager.getNextNonce(w)));
-                const profitTxs = await Promise.all(wallets.map((wallet, i) => wallet.signTransaction({
-                    to: config.profitRecipient,
-                    value: profit,
-                    nonce: profitNonces[i],
-                    gasPrice,
-                    gasLimit: 21000n,
-                    chainId: 56,
-                    type: getTxType(config)
-                })));
-                signedTxs.push(...profitTxs);
-                console.log(`   ✅ 已添加 ${wallets.length} 个利润转账交易\n`);
+        for (let i = 0; i < wallets.length; i++) {
+            if (quotedOutputs[i] > 0n) {
+                const { profit } = calculateProfit(quotedOutputs[i], config);
+                if (profit > 0n) {
+                    const profitNonce = await nonceManager.getNextNonce(wallets[i]);
+                    const profitTx = await wallets[i].signTransaction({
+                        to: config.profitRecipient,
+                        value: profit,
+                        nonce: profitNonce,
+                        gasPrice,
+                        gasLimit: 21000n,
+                        chainId: 56,
+                        type: getTxType(config)
+                    });
+                    signedTxs.push(profitTx);
+                }
             }
         }
-        else {
-            console.log(`⚠️  minFundsEach = 0，无法提取利润（建议传入 minFundsEach 参数）\n`);
-        }
     }
-    // ✅ 清理临时 nonce 缓存
     nonceManager.clearTemp();
-    console.log(`📦 Bundle 摘要:`);
-    console.log(`   总交易数: ${signedTxs.length}`);
-    console.log(`   - 卖出交易: ${signedSells.length}`);
-    console.log(`   - 利润交易: ${signedTxs.length - signedSells.length}`);
-    console.log(`\n⚠️  注意: 交易已签名，但尚未提交到链上`);
-    console.log(`   请将 signedTransactions 提交到服务器，由服务器调用 Merkle API\n`);
     // ✅ 简化返回：只返回签名交易
     return {
         signedTransactions: signedTxs

package/package.json

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