four-flap-meme-sdk 4.0.3 → 4.0.5

package/README.en.md

@@ -410,6 +410,9 @@ const result = await createTokenFlow({
     webUrl: 'https://example.com',
     twitterUrl: 'https://twitter.com/...',
     telegramUrl: 'https://t.me/...',
+    githubUrl: 'https://github.com/...',
+    youtubeUrl: 'https://youtube.com/...',
+    deboxUrl: 'https://debox.pro/...',
   }
 });
 
@@ -443,6 +446,9 @@ console.log('Your address:', result.accountAddress);
 | `webUrl` | string | ❌ | Project website |
 | `twitterUrl` | string | ❌ | Twitter/X profile |
 | `telegramUrl` | string | ❌ | Telegram group/channel |
+| `githubUrl` | string | ❌ | GitHub |
+| `youtubeUrl` | string | ❌ | YouTube |
+| `deboxUrl` | string | ❌ | DeBox |
 
 ### Return Value:
 
@@ -537,6 +543,9 @@ const { createArg, signature } = await four.createToken(accessToken, {
   webUrl: 'https://...',
   twitterUrl: 'https://...',
   telegramUrl: 'https://...',
+  githubUrl: 'https://...',
+  youtubeUrl: 'https://...',
+  deboxUrl: 'https://...',
 });
 ```
 
@@ -1035,7 +1044,10 @@ const { createArg, signature } = await four.createToken(
     onlyMPC?: boolean,            // MPC-exclusive flag
     webUrl?: string,              // Optional website
     twitterUrl?: string,          // Optional Twitter
-    telegramUrl?: string          // Optional Telegram
+    telegramUrl?: string,         // Optional Telegram
+    githubUrl?: string,          // Optional GitHub
+    youtubeUrl?: string,         // Optional YouTube
+    deboxUrl?: string            // Optional DeBox
   }
 );
 ```
@@ -2139,7 +2151,10 @@ const cid = await uploadTokenMeta(
     creator: walletAddress,
     website: 'https://example.com',
     twitter: 'https://x.com/mytoken',
-    telegram: 'https://t.me/mytoken'
+    telegram: 'https://t.me/mytoken',
+    github: 'https://github.com/mytoken',
+    youtube: 'https://youtube.com/@mytoken',
+    debox: 'https://debox.pro/mytoken',
   },
   'https://your-ipfs-graphql.example'
 );

package/README.zh-CN.md

@@ -425,6 +425,9 @@ const result = await createTokenFlow({
     webUrl: 'https://example.com',
     twitterUrl: 'https://twitter.com/...',
     telegramUrl: 'https://t.me/...',
+    githubUrl: 'https://github.com/...',
+    youtubeUrl: 'https://youtube.com/...',
+    deboxUrl: 'https://debox.pro/...',
   }
 });
 
@@ -460,6 +463,9 @@ console.log('你的地址:', result.accountAddress);
 | `webUrl` | string | ❌ | 项目网站 |
 | `twitterUrl` | string | ❌ | Twitter/X 账号 |
 | `telegramUrl` | string | ❌ | Telegram 群组/频道 |
+| `githubUrl` | string | ❌ | GitHub |
+| `youtubeUrl` | string | ❌ | YouTube |
+| `deboxUrl` | string | ❌ | DeBox |
 
 ### 返回值：
 
@@ -555,6 +561,9 @@ const { createArg, signature } = await four.createToken(accessToken, {
   webUrl: 'https://...',
   twitterUrl: 'https://...',
   telegramUrl: 'https://...',
+  githubUrl: 'https://...',
+  youtubeUrl: 'https://...',
+  deboxUrl: 'https://...',
 });
 ```
 
@@ -1035,7 +1044,10 @@ const { createArg, signature } = await four.createToken(
     onlyMPC?: boolean,            // MPC 专属标志
     webUrl?: string,              // 可选网站
     twitterUrl?: string,          // 可选 Twitter
-    telegramUrl?: string          // 可选 Telegram
+    telegramUrl?: string,         // 可选 Telegram
+    githubUrl?: string,          // 可选 GitHub
+    youtubeUrl?: string,         // 可选 YouTube
+    deboxUrl?: string            // 可选 DeBox
   }
 );
 ```
@@ -2505,7 +2517,10 @@ const cid = await uploadTokenMeta(imageFile as File, {
   creator: yourAddress,
   website: 'https://example.com',
   twitter: 'https://x.com/mytoken',
-  telegram: 'https://t.me/mytoken'
+  telegram: 'https://t.me/mytoken',
+  github: 'https://github.com/mytoken',
+  youtube: 'https://youtube.com/@mytoken',
+  debox: 'https://debox.pro/mytoken',
 }, 'https://your-ipfs-graphql.example');
 ```
 

package/dist/abis/openfour.d.ts

@@ -0,0 +1,94 @@
+/**
+ * OpenFour 最小 ABI：Registry 发现、schema 读取、createToken / buyByBudget
+ */
+export declare const OPENFOUR_REGISTRY_ABI: string[];
+export declare const OPENFOUR_CORE_ABI: string[];
+export declare const OPENFOUR_TOOLS_ABI: ({
+    type: string;
+    name: string;
+    stateMutability: string;
+    inputs: never[];
+    outputs: {
+        name: string;
+        type: string;
+        components: readonly [{
+            readonly name: "name";
+            readonly type: "string";
+        }, {
+            readonly name: "abiType";
+            readonly type: "string";
+        }, {
+            readonly name: "decimals";
+            readonly type: "uint8";
+        }, {
+            readonly name: "optional";
+            readonly type: "bool";
+        }, {
+            readonly name: "title";
+            readonly type: "string";
+        }, {
+            readonly name: "defaultValue";
+            readonly type: "string";
+        }, {
+            readonly name: "hint";
+            readonly type: "string";
+        }, {
+            readonly name: "minValue";
+            readonly type: "string";
+        }, {
+            readonly name: "maxValue";
+            readonly type: "string";
+        }];
+    }[];
+} | {
+    type: string;
+    name: string;
+    stateMutability: string;
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+        components: readonly [{
+            readonly name: "kind";
+            readonly type: "string";
+        }, {
+            readonly name: "version";
+            readonly type: "uint8";
+        }, {
+            readonly name: "params";
+            readonly type: "tuple[]";
+            readonly components: readonly [{
+                readonly name: "name";
+                readonly type: "string";
+            }, {
+                readonly name: "abiType";
+                readonly type: "string";
+            }, {
+                readonly name: "decimals";
+                readonly type: "uint8";
+            }, {
+                readonly name: "optional";
+                readonly type: "bool";
+            }, {
+                readonly name: "title";
+                readonly type: "string";
+            }, {
+                readonly name: "defaultValue";
+                readonly type: "string";
+            }, {
+                readonly name: "hint";
+                readonly type: "string";
+            }, {
+                readonly name: "minValue";
+                readonly type: "string";
+            }, {
+                readonly name: "maxValue";
+                readonly type: "string";
+            }];
+        }];
+    }[];
+})[];
+export declare const OPENFOUR_WETH_ABI: string[];

package/dist/abis/openfour.js

@@ -0,0 +1,63 @@
+/**
+ * OpenFour 最小 ABI：Registry 发现、schema 读取、createToken / buyByBudget
+ */
+const PARAM_COMPONENTS = [
+    { name: 'name', type: 'string' },
+    { name: 'abiType', type: 'string' },
+    { name: 'decimals', type: 'uint8' },
+    { name: 'optional', type: 'bool' },
+    { name: 'title', type: 'string' },
+    { name: 'defaultValue', type: 'string' },
+    { name: 'hint', type: 'string' },
+    { name: 'minValue', type: 'string' },
+    { name: 'maxValue', type: 'string' },
+];
+const MODULE_SCHEMA_COMPONENTS = [
+    { name: 'kind', type: 'string' },
+    { name: 'version', type: 'uint8' },
+    { name: 'params', type: 'tuple[]', components: PARAM_COMPONENTS },
+];
+export const OPENFOUR_REGISTRY_ABI = [
+    'function openFourCore() view returns (address)',
+    'function openFourTool() view returns (address)',
+    'function isPresetActive(uint256 presetId) view returns (bool)',
+    'function isPresetCreateEnabled(uint256 presetId) view returns (bool)',
+];
+export const OPENFOUR_CORE_ABI = [
+    'function createToken(bytes createArgs, bytes signature) payable returns (address token)',
+    'function wrappedNative() view returns (address)',
+    'function feeRouter() view returns (address)',
+    'function zapRouter() view returns (address)',
+    'function buyByBudget(address token, uint256 maxPayAmount, uint256 minAmountOut, uint256 options, bytes proof) payable',
+    'function buy(address token, uint256 amount, uint256 maxPayAmount, uint256 options, bytes proof) payable',
+    'event TokenCreated(address indexed token, address indexed creator, uint256 indexed presetId)',
+];
+export const OPENFOUR_TOOLS_ABI = [
+    {
+        type: 'function',
+        name: 'getTokenBaseSchema',
+        stateMutability: 'pure',
+        inputs: [],
+        outputs: [{ name: '', type: 'tuple[]', components: PARAM_COMPONENTS }],
+    },
+    {
+        type: 'function',
+        name: 'getPresetEncodeSchemas',
+        stateMutability: 'view',
+        inputs: [{ name: 'presetId', type: 'uint256' }],
+        outputs: [
+            { name: 'tokenSchema', type: 'tuple', components: MODULE_SCHEMA_COMPONENTS },
+            { name: 'vaultSchema', type: 'tuple', components: MODULE_SCHEMA_COMPONENTS },
+            { name: 'curveSchema', type: 'tuple', components: MODULE_SCHEMA_COMPONENTS },
+            { name: 'tradeSchema', type: 'tuple', components: MODULE_SCHEMA_COMPONENTS },
+            { name: 'migrateSchema', type: 'tuple', components: MODULE_SCHEMA_COMPONENTS },
+            { name: 'customDataSchema', type: 'tuple', components: MODULE_SCHEMA_COMPONENTS },
+        ],
+    },
+];
+export const OPENFOUR_WETH_ABI = [
+    'function deposit() payable',
+    'function approve(address spender, uint256 amount) returns (bool)',
+    'function allowance(address owner, address spender) view returns (uint256)',
+    'function decimals() view returns (uint8)',
+];

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

@@ -0,0 +1,26 @@
+import type { FourCreateWithBundleBuyMerkleResult, FourSignConfig } from '../types/index.js';
+import { type OpenFourInitParams, type OpenFourTemplateConfig } from '../../../domains/openfour/index.js';
+export type OpenFourCreateSignParams = {
+    privateKeys: string[];
+    tokenInfo: {
+        name: string;
+        symbol: string;
+        description: string;
+        imageUrl?: string;
+        imageFile?: Blob;
+        webUrl?: string;
+        twitterUrl?: string;
+        telegramUrl?: string;
+        githubUrl?: string;
+        youtubeUrl?: string;
+        deboxUrl?: string;
+        preSale?: string;
+        feePlan?: boolean;
+        templateId: number | string;
+        quoteSymbol: string;
+        templateConfig: OpenFourTemplateConfig;
+        initParams: OpenFourInitParams;
+    };
+    config: FourSignConfig;
+};
+export declare function createOpenFourTokenMerkle(params: OpenFourCreateSignParams): Promise<FourCreateWithBundleBuyMerkleResult>;

package/dist/bundle/four-meme/core/create-openfour.js

@@ -0,0 +1,121 @@
+/**
+ * OpenFour 发币：业务 API 拿 createArg + signature，再签 OpenFourCore.createToken
+ */
+import { Contract, Wallet } from 'ethers';
+import { getGasLimit } from '../../../core/gas/bundle-gas.js';
+import { NonceManager, getOptimizedGasPrice } from '../../../utils/bundle-helpers.js';
+import { ZERO_ADDRESS } from '../../../core/constants/index.js';
+import { FourClient } from '../../../core/clients/four.js';
+import { getTxType, getGasPriceConfig, getBribeAmount } from '../../config-helpers.js';
+import { signBribeTransaction } from '../../../core/sign-context-helpers.js';
+import { createChainContext, loginFourClient, resolveTokenImage } from '../core-helpers.js';
+import { OPENFOUR_CORE_ABI } from '../../../abis/openfour.js';
+import { computeOpenFourCreateValueWei, decodeOpenFourCreateArg, isOpenFourPresaleNative, loadOpenFourAddresses, } from '../../../domains/openfour/index.js';
+import { signQuoteApproveIfNeeded } from './create-token-quote.js';
+function toRaisedToken(cfg) {
+    return {
+        symbol: cfg.symbol,
+        nativeSymbol: cfg.symbol,
+        symbolAddress: cfg.symbolAddress,
+        deployCost: cfg.createFee || '0',
+        buyFee: '0',
+        sellFee: '0',
+        minTradeFee: '0',
+        b0Amount: '0',
+        totalBAmount: cfg.raisedAmount,
+        totalAmount: cfg.totalSupply,
+        logoUrl: '',
+        tradeLevel: [],
+        status: 'PUBLISH',
+        buyTokenLink: '',
+        reservedNumber: 0,
+        saleRate: '0.8',
+        networkCode: 'BSC',
+        platform: 'MEME',
+    };
+}
+export async function createOpenFourTokenMerkle(params) {
+    const { privateKeys, tokenInfo, config } = params;
+    if (privateKeys.length !== 1) {
+        throw new Error('OpenFour 发币只支持 1 个 Dev 钱包');
+    }
+    const rpcUrl = config.rpcUrl || 'https://bsc-dataseed.binance.org';
+    const { provider, chainId } = createChainContext(rpcUrl);
+    const devWallet = new Wallet(privateKeys[0], provider);
+    const fourClient = new FourClient({ baseUrl: config.fourApiUrl });
+    const accessToken = await loginFourClient(devWallet, fourClient);
+    const imgUrl = await resolveTokenImage(fourClient, tokenInfo, accessToken);
+    const preSale = String(tokenInfo.preSale || '0').trim() || '0';
+    const cfg = tokenInfo.templateConfig;
+    const body = {
+        templateId: tokenInfo.templateId,
+        name: tokenInfo.name,
+        shortName: tokenInfo.symbol,
+        symbol: cfg.symbol,
+        desc: tokenInfo.description,
+        imgUrl,
+        webUrl: tokenInfo.webUrl,
+        twitterUrl: tokenInfo.twitterUrl,
+        telegramUrl: tokenInfo.telegramUrl,
+        githubUrl: tokenInfo.githubUrl,
+        youtubeUrl: tokenInfo.youtubeUrl,
+        deboxUrl: tokenInfo.deboxUrl,
+        presaleQuote: preSale,
+        feePlan: Boolean(tokenInfo.feePlan),
+        initParams: tokenInfo.initParams,
+        saleAmount: cfg.saleAmount,
+        totalSupply: cfg.totalSupply,
+        raisedAmount: cfg.raisedAmount,
+    };
+    const createResp = await fourClient.createOpenFourToken(accessToken, body);
+    const addrs = await loadOpenFourAddresses(provider);
+    const decoded = decodeOpenFourCreateArg(createResp.createArg);
+    const valueWei = computeOpenFourCreateValueWei(decoded, addrs.wrappedNative);
+    const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
+    const nonceManager = new NonceManager(provider);
+    const txType = getTxType(config);
+    const signedTxs = [];
+    const bribeAmount = getBribeAmount(config);
+    if (bribeAmount > 0n) {
+        const bribeNonce = await nonceManager.getNextNonce(devWallet);
+        signedTxs.push(await signBribeTransaction(devWallet, bribeAmount, bribeNonce, gasPrice, chainId, txType));
+    }
+    const nativePresale = isOpenFourPresaleNative({
+        presaleQuote: decoded.presaleQuote,
+        quoteAsset: decoded.quoteAsset,
+        wrappedNative: addrs.wrappedNative,
+    });
+    if (!nativePresale && decoded.presaleQuote > 0n) {
+        const approveTx = await signQuoteApproveIfNeeded({
+            raisedToken: toRaisedToken(cfg),
+            preSale,
+            wallet: devWallet,
+            spender: addrs.core,
+            getNonce: () => nonceManager.getNextNonce(devWallet),
+            gasPrice,
+            chainId,
+            txType,
+        });
+        if (approveTx)
+            signedTxs.push(approveTx);
+    }
+    const core = new Contract(addrs.core, OPENFOUR_CORE_ABI, devWallet);
+    const unsigned = await core.createToken.populateTransaction(createResp.createArg, createResp.signature, {
+        value: valueWei,
+    });
+    signedTxs.push(await devWallet.signTransaction({
+        ...unsigned,
+        from: devWallet.address,
+        nonce: await nonceManager.getNextNonce(devWallet),
+        gasLimit: getGasLimit(config, 2_000_000),
+        gasPrice,
+        chainId,
+        type: txType,
+        value: valueWei,
+    }));
+    nonceManager.clearTemp();
+    return {
+        signedTransactions: signedTxs,
+        tokenAddress: ZERO_ADDRESS,
+    };
+}

package/dist/bundle/four-meme/core/create-token.js

@@ -41,6 +41,9 @@ export async function createTokenWithBundleBuyMerkle(params) {
         webUrl: tokenInfo.webUrl,
         twitterUrl: tokenInfo.twitterUrl,
         telegramUrl: tokenInfo.telegramUrl,
+        githubUrl: tokenInfo.githubUrl,
+        youtubeUrl: tokenInfo.youtubeUrl,
+        deboxUrl: tokenInfo.deboxUrl,
         preSale: effectivePreSaleStr || '0',
         onlyMPC: false,
         ...(tokenInfo.feePlan ? { feePlan: true } : {}),

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

@@ -10,5 +10,7 @@
  * 对外 export 符号与路径保持不变。
  */
 export { createTokenWithBundleBuyMerkle } from './create-token.js';
+export { createOpenFourTokenMerkle } from './create-openfour.js';
+export type { OpenFourCreateSignParams } from './create-openfour.js';
 export { batchBuyWithBundleMerkle } from './buy-flow.js';
 export { batchSellWithBundleMerkle } from './sell-flow.js';

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

@@ -10,5 +10,6 @@
  * 对外 export 符号与路径保持不变。
  */
 export { createTokenWithBundleBuyMerkle } from './create-token.js';
+export { createOpenFourTokenMerkle } from './create-openfour.js';
 export { batchBuyWithBundleMerkle } from './buy-flow.js';
 export { batchSellWithBundleMerkle } from './sell-flow.js';

package/dist/bundle/four-meme/private/buy-quote.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Four TokenManager 买入付款：BNB 走 msg.value；ERC20 计价走 approve + funds
+ */
+import { Wallet, type JsonRpcProvider } from 'ethers';
+import { NonceManager } from '../../../utils/bundle-helpers.js';
+export type FourBuyQuoteInput = {
+    /** ERC20 计价地址；不传则按 BNB */
+    quoteTokenAddress?: string;
+    quoteDecimals?: number;
+};
+export type FourBuyPayment = {
+    fundsWei: bigint;
+    valueWei: bigint;
+    quoteAddress?: string;
+    approvalWei: bigint;
+};
+export declare function isFourErc20BuyQuote(quoteTokenAddress?: string): boolean;
+export declare function resolveQuoteDecimals(provider: JsonRpcProvider, quote: FourBuyQuoteInput): Promise<number>;
+export declare function resolveFourBuyPayment(params: {
+    provider: JsonRpcProvider;
+    tokenAddress: string;
+    funds: string;
+    quote?: FourBuyQuoteInput;
+}): Promise<FourBuyPayment>;
+export declare function signQuoteApproveTxs(params: {
+    wallets: Wallet[];
+    quoteAddress: string;
+    spender: string;
+    amounts: bigint[];
+    nonceManager: NonceManager;
+    gasPrice: bigint;
+    chainId: number;
+    txType: number;
+    provider: JsonRpcProvider;
+}): Promise<string[]>;

package/dist/bundle/four-meme/private/buy-quote.js

@@ -0,0 +1,70 @@
+/**
+ * Four TokenManager 买入付款：BNB 走 msg.value；ERC20 计价走 approve + funds
+ */
+import { Contract, parseEther, parseUnits } from 'ethers';
+import { ADDRESSES, ZERO_ADDRESS } from '../../../core/constants/index.js';
+import { ERC20_ABI } from '../../../abis/common.js';
+import { batchCheckAllowances } from '../../../core/erc20/index.js';
+const HELPER_TRY_BUY_ABI = [
+    'function tryBuy(address token, uint256 amount, uint256 funds) view returns (address tokenManager, address quote, uint256 estimatedAmount, uint256 estimatedCost, uint256 estimatedFee, uint256 amountMsgValue, uint256 amountApproval, uint256 amountFunds)',
+];
+export function isFourErc20BuyQuote(quoteTokenAddress) {
+    if (!quoteTokenAddress)
+        return false;
+    return quoteTokenAddress.toLowerCase() !== ZERO_ADDRESS.toLowerCase();
+}
+export async function resolveQuoteDecimals(provider, quote) {
+    if (quote.quoteDecimals != null)
+        return quote.quoteDecimals;
+    if (!isFourErc20BuyQuote(quote.quoteTokenAddress))
+        return 18;
+    const token = new Contract(quote.quoteTokenAddress, ERC20_ABI, provider);
+    return Number(await token.decimals());
+}
+export async function resolveFourBuyPayment(params) {
+    const quote = params.quote ?? {};
+    if (!isFourErc20BuyQuote(quote.quoteTokenAddress)) {
+        const fundsWei = parseEther(params.funds);
+        return { fundsWei, valueWei: fundsWei, approvalWei: 0n };
+    }
+    const decimals = await resolveQuoteDecimals(params.provider, quote);
+    const fundsWei = parseUnits(params.funds, decimals);
+    const quoteAddress = quote.quoteTokenAddress;
+    try {
+        const helper = new Contract(ADDRESSES.BSC.TokenManagerHelper3, HELPER_TRY_BUY_ABI, params.provider);
+        const preview = await helper.tryBuy(params.tokenAddress, 0n, fundsWei);
+        const amountFunds = preview.amountFunds > 0n ? preview.amountFunds : fundsWei;
+        return {
+            fundsWei: amountFunds,
+            valueWei: preview.amountMsgValue,
+            quoteAddress: preview.quote || quoteAddress,
+            approvalWei: preview.amountApproval,
+        };
+    }
+    catch {
+        return { fundsWei, valueWei: 0n, quoteAddress, approvalWei: fundsWei };
+    }
+}
+export async function signQuoteApproveTxs(params) {
+    const { wallets, quoteAddress, spender, amounts, nonceManager, gasPrice, chainId, txType, provider } = params;
+    if (wallets.length === 0)
+        return [];
+    const allowances = await batchCheckAllowances(provider, quoteAddress, wallets.map((w) => w.address), spender);
+    const signed = [];
+    for (let i = 0; i < wallets.length; i++) {
+        if (allowances[i] >= amounts[i])
+            continue;
+        const token = new Contract(quoteAddress, ERC20_ABI, wallets[i]);
+        const unsigned = await token.approve.populateTransaction(spender, amounts[i]);
+        signed.push(await wallets[i].signTransaction({
+            ...unsigned,
+            from: wallets[i].address,
+            nonce: await nonceManager.getNextNonce(wallets[i]),
+            gasLimit: 80000n,
+            gasPrice,
+            chainId,
+            type: txType,
+        }));
+    }
+    return signed;
+}