four-flap-meme-sdk 4.0.2 → 4.0.4

package/dist/domains/four/tax-token.test.js

@@ -0,0 +1,89 @@
+import { describe, expect, it } from 'vitest';
+import { parseEther } from 'ethers';
+import { validateFourTokenTaxInfo } from './tax-token.js';
+import { computeOpenFourCreateValueWei, encodeOpenFourModuleParams, isOpenFourPresaleNative, } from '../openfour/index.js';
+describe('validateFourTokenTaxInfo TaxToken9', () => {
+    it('four-way sum still 100 without charity fields', () => {
+        expect(validateFourTokenTaxInfo({
+            feeRate: 5,
+            burnRate: 20,
+            divideRate: 30,
+            liquidityRate: 40,
+            recipientRate: 10,
+            minSharing: 100000,
+        }).valid).toBe(true);
+    });
+    it('includes charity rates in the 100 sum', () => {
+        expect(validateFourTokenTaxInfo({
+            feeRate: 5,
+            burnRate: 20,
+            divideRate: 20,
+            liquidityRate: 40,
+            recipientRate: 10,
+            giggleCharityRate: 5,
+            binanceCharityRate: 5,
+            minSharing: 100000,
+        }).valid).toBe(true);
+    });
+    it('rejects six-way sum not 100', () => {
+        const r = validateFourTokenTaxInfo({
+            feeRate: 5,
+            burnRate: 20,
+            divideRate: 30,
+            liquidityRate: 40,
+            recipientRate: 10,
+            giggleCharityRate: 5,
+            binanceCharityRate: 0,
+            minSharing: 100000,
+        });
+        expect(r.valid).toBe(false);
+    });
+});
+describe('OpenFour schema encode', () => {
+    it('empty schema encodes to 0x', () => {
+        const schema = { kind: 'token', version: 1, params: [] };
+        expect(encodeOpenFourModuleParams(schema, {})).toBe('0x');
+    });
+    it('encodes a uint tuple', () => {
+        const schema = {
+            kind: 'token',
+            version: 1,
+            params: [
+                {
+                    name: 'buyFeeRate',
+                    abiType: 'uint16',
+                    decimals: 0,
+                    optional: false,
+                    title: 'buy',
+                    defaultValue: '100',
+                    hint: '',
+                    minValue: '',
+                    maxValue: '',
+                },
+            ],
+        };
+        expect(encodeOpenFourModuleParams(schema, { buyFeeRate: '100' })).toMatch(/^0x/);
+    });
+});
+describe('OpenFour create value', () => {
+    const wbnb = '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c';
+    const usdt = '0x55d398326f99059fF775485246999027B3197955';
+    it('BNB quote adds presale into msg.value', () => {
+        const decoded = {
+            createFee: parseEther('0.01'),
+            presaleQuote: parseEther('0.2'),
+            quoteAsset: wbnb,
+        };
+        expect(isOpenFourPresaleNative({ ...decoded, wrappedNative: wbnb })).toBe(true);
+        expect(computeOpenFourCreateValueWei(decoded, wbnb)).toBe(parseEther('0.21'));
+    });
+    it('ERC20 quote pays createFee only', () => {
+        const decoded = {
+            createFee: parseEther('0.01'),
+            presaleQuote: parseEther('100'),
+            quoteAsset: usdt,
+        };
+        expect(isOpenFourPresaleNative({ ...decoded, wrappedNative: wbnb })).toBe(false);
+        expect(computeOpenFourCreateValueWei(decoded, wbnb)).toBe(parseEther('0.01'));
+    });
+});

package/dist/domains/openfour/create-arg.d.ts

@@ -0,0 +1,13 @@
+export type OpenFourDecodedCreateArg = {
+    createFee: bigint;
+    presaleQuote: bigint;
+    quoteAsset: string;
+};
+export declare function decodeOpenFourCreateArg(rawCreateArg: string): OpenFourDecodedCreateArg;
+export declare function isOpenFourPresaleNative(params: {
+    presaleQuote: bigint;
+    quoteAsset: string;
+    wrappedNative: string;
+}): boolean;
+/** OpenFourCore.createToken 的 msg.value：createFee 始终付 BNB；预购仅在 quote=WBNB 时加进 value */
+export declare function computeOpenFourCreateValueWei(decoded: OpenFourDecodedCreateArg, wrappedNative: string): bigint;

package/dist/domains/openfour/create-arg.js

@@ -0,0 +1,78 @@
+import { AbiCoder, ParamType } from 'ethers';
+const INIT_PARAMS_14 = [
+    { name: 'name', type: 'string' },
+    { name: 'symbol', type: 'string' },
+    { name: 'tokenUri', type: 'string' },
+    { name: 'maxSupply', type: 'uint256' },
+    { name: 'saleAmount', type: 'uint256' },
+    { name: 'raiseAmount', type: 'uint256' },
+    { name: 'quoteAsset', type: 'address' },
+    { name: 'tokenSalt', type: 'bytes32' },
+    { name: 'tokenParams', type: 'bytes' },
+    { name: 'vaultParams', type: 'bytes' },
+    { name: 'curveParams', type: 'bytes' },
+    { name: 'tradeParams', type: 'bytes' },
+    { name: 'migrateParams', type: 'bytes' },
+    { name: 'customDataParams', type: 'bytes' },
+];
+const INIT_PARAMS_13 = INIT_PARAMS_14.slice(0, 13);
+const OUTER = [
+    { name: 'requestId', type: 'uint256' },
+    { name: 'presetId', type: 'uint256' },
+    { name: 'validTimestamp', type: 'uint256' },
+    { name: 'createFee', type: 'uint256' },
+    { name: 'presaleQuote', type: 'uint256' },
+    { name: 'antiSniperEnabled', type: 'bool' },
+];
+const ABI_14 = [
+    ParamType.from({
+        type: 'tuple',
+        components: [...OUTER, { name: 'initParams', type: 'tuple', components: INIT_PARAMS_14 }],
+    }),
+];
+const ABI_13 = [
+    ParamType.from({
+        type: 'tuple',
+        components: [
+            ...OUTER,
+            { name: 'initParams', type: 'tuple', components: INIT_PARAMS_13 },
+        ],
+    }),
+];
+const coder = AbiCoder.defaultAbiCoder();
+function toBigInt(value) {
+    if (value == null)
+        return 0n;
+    if (typeof value === 'bigint')
+        return value;
+    return BigInt(String(value));
+}
+export function decodeOpenFourCreateArg(rawCreateArg) {
+    let decoded;
+    try {
+        [decoded] = coder.decode(ABI_14, rawCreateArg);
+    }
+    catch {
+        [decoded] = coder.decode(ABI_13, rawCreateArg);
+    }
+    const row = decoded;
+    return {
+        createFee: toBigInt(row.createFee),
+        presaleQuote: toBigInt(row.presaleQuote),
+        quoteAsset: String(row.initParams?.quoteAsset ?? ''),
+    };
+}
+export function isOpenFourPresaleNative(params) {
+    if (params.presaleQuote <= 0n)
+        return false;
+    const q = params.quoteAsset.toLowerCase();
+    const w = params.wrappedNative.toLowerCase();
+    return Boolean(q && w && q === w);
+}
+/** OpenFourCore.createToken 的 msg.value：createFee 始终付 BNB；预购仅在 quote=WBNB 时加进 value */
+export function computeOpenFourCreateValueWei(decoded, wrappedNative) {
+    if (isOpenFourPresaleNative({ ...decoded, wrappedNative })) {
+        return decoded.createFee + decoded.presaleQuote;
+    }
+    return decoded.createFee;
+}

package/dist/domains/openfour/index.d.ts

@@ -0,0 +1,4 @@
+export type { OpenFourAddresses, OpenFourCreateReq, OpenFourInitParams, OpenFourModuleSchema, OpenFourParamDescriptor, OpenFourPresetSchemas, OpenFourTemplate, OpenFourTemplateConfig, } from './types.js';
+export { collectOpenFourSchemaParams, defaultOpenFourFormFromSchema, emptyOpenFourInitParams, encodeOpenFourInitParams, encodeOpenFourModuleParams, } from './schema.js';
+export { computeOpenFourCreateValueWei, decodeOpenFourCreateArg, isOpenFourPresaleNative, type OpenFourDecodedCreateArg, } from './create-arg.js';
+export { loadOpenFourAddresses, loadOpenFourPresetSchemas } from './registry.js';

package/dist/domains/openfour/index.js

@@ -0,0 +1,3 @@
+export { collectOpenFourSchemaParams, defaultOpenFourFormFromSchema, emptyOpenFourInitParams, encodeOpenFourInitParams, encodeOpenFourModuleParams, } from './schema.js';
+export { computeOpenFourCreateValueWei, decodeOpenFourCreateArg, isOpenFourPresaleNative, } from './create-arg.js';
+export { loadOpenFourAddresses, loadOpenFourPresetSchemas } from './registry.js';

package/dist/domains/openfour/registry.d.ts

@@ -0,0 +1,4 @@
+import { type Provider } from 'ethers';
+import type { OpenFourAddresses, OpenFourPresetSchemas } from './types.js';
+export declare function loadOpenFourAddresses(provider: Provider, registryAddress?: string): Promise<OpenFourAddresses>;
+export declare function loadOpenFourPresetSchemas(provider: Provider, presetId: number | string, toolsAddress?: string): Promise<OpenFourPresetSchemas>;

package/dist/domains/openfour/registry.js

@@ -0,0 +1,44 @@
+import { Contract } from 'ethers';
+import { ADDRESSES } from '../../core/constants/index.js';
+import { OPENFOUR_CORE_ABI, OPENFOUR_REGISTRY_ABI, OPENFOUR_TOOLS_ABI } from '../../abis/openfour.js';
+function mapParam(raw) {
+    return {
+        name: raw.name,
+        abiType: raw.abiType,
+        decimals: Number(raw.decimals),
+        optional: raw.optional,
+        title: raw.title,
+        defaultValue: raw.defaultValue,
+        hint: raw.hint,
+        minValue: raw.minValue,
+        maxValue: raw.maxValue,
+    };
+}
+function mapSchema(raw) {
+    return {
+        kind: raw.kind,
+        version: Number(raw.version),
+        params: (raw.params ?? []).map(mapParam),
+    };
+}
+export async function loadOpenFourAddresses(provider, registryAddress) {
+    const registry = registryAddress || ADDRESSES.BSC.OpenFourRegistry;
+    const reg = new Contract(registry, OPENFOUR_REGISTRY_ABI, provider);
+    const [core, tools] = await Promise.all([reg.openFourCore(), reg.openFourTool()]);
+    const coreC = new Contract(core, OPENFOUR_CORE_ABI, provider);
+    const wrappedNative = (await coreC.wrappedNative());
+    return { registry, core: core, tools: tools, wrappedNative };
+}
+export async function loadOpenFourPresetSchemas(provider, presetId, toolsAddress) {
+    const toolsAddr = toolsAddress ?? (await loadOpenFourAddresses(provider)).tools;
+    const tools = new Contract(toolsAddr, OPENFOUR_TOOLS_ABI, provider);
+    const raw = await tools.getPresetEncodeSchemas(BigInt(presetId));
+    return {
+        token: mapSchema(raw.tokenSchema ?? raw[0]),
+        vault: mapSchema(raw.vaultSchema ?? raw[1]),
+        curve: mapSchema(raw.curveSchema ?? raw[2]),
+        trade: mapSchema(raw.tradeSchema ?? raw[3]),
+        migrate: mapSchema(raw.migrateSchema ?? raw[4]),
+        customData: mapSchema(raw.customDataSchema ?? raw[5]),
+    };
+}

package/dist/domains/openfour/schema.d.ts

@@ -0,0 +1,20 @@
+import type { OpenFourInitParams, OpenFourModuleSchema, OpenFourParamDescriptor } from './types.js';
+export declare function emptyOpenFourInitParams(): OpenFourInitParams;
+export declare function encodeOpenFourModuleParams(schema: OpenFourModuleSchema, form: Record<string, unknown>): string;
+export declare function defaultOpenFourFormFromSchema(params: OpenFourParamDescriptor[]): Record<string, string>;
+export declare function encodeOpenFourInitParams(schemas: {
+    token: OpenFourModuleSchema;
+    vault: OpenFourModuleSchema;
+    curve: OpenFourModuleSchema;
+    trade: OpenFourModuleSchema;
+    migrate: OpenFourModuleSchema;
+    customData: OpenFourModuleSchema;
+}, form: Record<string, unknown>): OpenFourInitParams;
+export declare function collectOpenFourSchemaParams(schemas: {
+    token: OpenFourModuleSchema;
+    vault: OpenFourModuleSchema;
+    curve: OpenFourModuleSchema;
+    trade: OpenFourModuleSchema;
+    migrate: OpenFourModuleSchema;
+    customData: OpenFourModuleSchema;
+}): OpenFourParamDescriptor[];

package/dist/domains/openfour/schema.js

@@ -0,0 +1,88 @@
+import { AbiCoder, ZeroAddress, ZeroHash, parseUnits } from 'ethers';
+const coder = AbiCoder.defaultAbiCoder();
+export function emptyOpenFourInitParams() {
+    return {
+        tokenParams: '0x',
+        vaultParams: '0x',
+        curveParams: '0x',
+        tradeParams: '0x',
+        migrateParams: '0x',
+        customDataParams: '0x',
+    };
+}
+function zeroValue(abiType) {
+    if (abiType === 'address')
+        return ZeroAddress;
+    if (abiType === 'bool')
+        return false;
+    if (abiType === 'string')
+        return '';
+    if (abiType === 'bytes')
+        return '0x';
+    if (abiType === 'bytes32')
+        return ZeroHash;
+    return 0n;
+}
+function resolveParam(desc, form) {
+    const raw = form[desc.name];
+    const str = String(raw ?? '').trim();
+    const missing = raw == null || str === '';
+    if (missing) {
+        if (desc.optional)
+            return zeroValue(desc.abiType);
+        throw new Error(`OpenFour schema: required param "${desc.name}" is missing`);
+    }
+    switch (desc.abiType) {
+        case 'bool':
+            if (typeof raw === 'boolean')
+                return raw;
+            return str === 'true' || str === '1';
+        case 'address':
+            return str || ZeroAddress;
+        case 'string':
+            return str;
+        case 'bytes32':
+            return str || ZeroHash;
+        case 'bytes':
+            return str || '0x';
+        default:
+            if (desc.decimals > 0)
+                return parseUnits(str, desc.decimals);
+            return BigInt(str);
+    }
+}
+export function encodeOpenFourModuleParams(schema, form) {
+    if (!schema.params.length)
+        return '0x';
+    const types = schema.params.map((p) => p.abiType);
+    const values = schema.params.map((p) => resolveParam(p, form));
+    return coder.encode([`(${types.join(',')})`], [values]);
+}
+export function defaultOpenFourFormFromSchema(params) {
+    const out = {};
+    for (const p of params) {
+        if (p.defaultValue !== '')
+            out[p.name] = p.defaultValue;
+    }
+    return out;
+}
+export function encodeOpenFourInitParams(schemas, form) {
+    return {
+        tokenParams: encodeOpenFourModuleParams(schemas.token, form),
+        vaultParams: encodeOpenFourModuleParams(schemas.vault, form),
+        curveParams: encodeOpenFourModuleParams(schemas.curve, form),
+        tradeParams: encodeOpenFourModuleParams(schemas.trade, form),
+        migrateParams: encodeOpenFourModuleParams(schemas.migrate, form),
+        customDataParams: encodeOpenFourModuleParams(schemas.customData, form),
+    };
+}
+export function collectOpenFourSchemaParams(schemas) {
+    return [
+        ...schemas.token.params,
+        ...schemas.vault.params,
+        ...schemas.curve.params,
+        ...schemas.trade.params,
+        ...schemas.migrate.params,
+        ...schemas.customData.params,
+    ];
+}

package/dist/domains/openfour/types.d.ts

@@ -0,0 +1,76 @@
+export type OpenFourParamDescriptor = {
+    name: string;
+    abiType: string;
+    decimals: number;
+    optional: boolean;
+    title: string;
+    defaultValue: string;
+    hint: string;
+    minValue: string;
+    maxValue: string;
+};
+export type OpenFourModuleSchema = {
+    kind: string;
+    version: number;
+    params: OpenFourParamDescriptor[];
+};
+export type OpenFourPresetSchemas = {
+    token: OpenFourModuleSchema;
+    vault: OpenFourModuleSchema;
+    curve: OpenFourModuleSchema;
+    trade: OpenFourModuleSchema;
+    migrate: OpenFourModuleSchema;
+    customData: OpenFourModuleSchema;
+};
+export type OpenFourInitParams = {
+    tokenParams: string;
+    vaultParams: string;
+    curveParams: string;
+    tradeParams: string;
+    migrateParams: string;
+    customDataParams: string;
+};
+export type OpenFourTemplate = {
+    id: number | string;
+    name: string;
+    tag: string;
+    descr: string;
+    status: string;
+    amount: string;
+    imgUrl: string;
+    deploys: number;
+};
+export type OpenFourTemplateConfig = {
+    id: number;
+    symbol: string;
+    symbolAddress: string;
+    totalSupply: string;
+    saleAmount: string;
+    raisedAmount: string;
+    createFee: string;
+    decimals: number;
+    fullName?: string;
+};
+export type OpenFourCreateReq = {
+    templateId: number | string;
+    name: string;
+    shortName: string;
+    symbol: string;
+    desc: string;
+    imgUrl: string;
+    webUrl?: string;
+    telegramUrl?: string;
+    twitterUrl?: string;
+    presaleQuote: string | number;
+    feePlan: boolean;
+    initParams: OpenFourInitParams;
+    saleAmount?: string;
+    totalSupply?: string;
+    raisedAmount?: string;
+};
+export type OpenFourAddresses = {
+    registry: string;
+    core: string;
+    tools: string;
+    wrappedNative: string;
+};

package/dist/domains/openfour/types.js

@@ -0,0 +1 @@
+export {};

package/dist/exports/root-bundle-and-tooling.d.ts

@@ -13,8 +13,8 @@ export { createTokenWithBundleBuy as flapCreateTokenWithBundleBuy, batchBuyWithB
 export { fourPrivateBuy, fourPrivateSell, fourBatchPrivateBuy, fourBatchPrivateSell, type FourPrivateBuyParams, type FourPrivateSellParams, type FourBatchPrivateBuyParams, type FourBatchPrivateSellParams, } from '../domains/four/contracts/tm-bundle.js';
 export { flapPrivateBuy, flapPrivateSell, flapBatchPrivateBuy, flapBatchPrivateSell, type FlapPrivateBuyParams, type FlapPrivateSellParams, type FlapBatchPrivateBuyParams, type FlapBatchPrivateSellParams, type FlapBatchPrivateSellResult, } from '../domains/flap/portal-bundle.js';
 export { createTokenWithBundleBuyMerkle as flapCreateTokenWithBundleBuyMerkle, batchBuyWithBundleMerkle as flapBatchBuyWithBundleMerkle, batchSellWithBundleMerkle as flapBatchSellWithBundleMerkle, flapPrivateBuyMerkle, flapPrivateSellMerkle, flapBatchPrivateBuyMerkle, flapBatchPrivateSellMerkle, pancakeProxyBatchBuyMerkle, pancakeProxyBatchSellMerkle, approvePancakeProxy, approvePancakeProxyBatch, flapDisperseWithBundleMerkle, flapSweepWithBundleMerkle, type FlapBundleMerkleConfig, type FlapSignConfig, type FlapProfitMode, type FlapChainForMerkleBundle, type FlapCreateWithBundleBuySignParams, type FlapCreateWithBundleBuyMerkleParams, type FlapCreateWithBundleBuyMerkleResult, type FlapBatchBuySignParams, type FlapBatchBuyMerkleParams, type FlapBatchBuyMerkleResult, type FlapBatchSellSignParams, type FlapBatchSellMerkleParams, type FlapBatchSellMerkleResult, type MerkleTransactionStatus, type MerkleBundleStatus, type FlapPrivateBuyMerkleParams, type FlapPrivateSellMerkleParams, type FlapBatchPrivateBuyMerkleParams, type FlapBatchPrivateSellMerkleParams, type FlapBatchPrivateMerkleResult, type FlapPrivateTransactionResult, type PancakeProxyBatchBuyParams, type PancakeProxyBatchBuyResult, type PancakeProxyBatchSellParams, type PancakeProxyBatchSellResult, type PancakeProxyApprovalParams, type PancakeProxyApprovalBatchParams, type PancakeProxyApprovalBatchResult, type FlapDisperseSignParams, type FlapDisperseMerkleResult, type FlapSweepSignParams, type FlapSweepMerkleResult, } from '../domains/flap/portal-bundle-merkle/index.js';
-export { createTokenWithBundleBuyMerkle as fourCreateTokenWithBundleBuyMerkle, batchBuyWithBundleMerkle as fourBatchBuyWithBundleMerkle, batchSellWithBundleMerkle as fourBatchSellWithBundleMerkle, } from '../bundle/four-meme/core.js';
-export { fourPrivateBuyMerkle, fourPrivateSellMerkle, fourBatchPrivateBuyMerkle, fourBatchPrivateSellMerkle, } from '../bundle/four-meme/private.js';
+export { createTokenWithBundleBuyMerkle as fourCreateTokenWithBundleBuyMerkle, createOpenFourTokenMerkle as fourCreateOpenFourTokenMerkle, batchBuyWithBundleMerkle as fourBatchBuyWithBundleMerkle, batchSellWithBundleMerkle as fourBatchSellWithBundleMerkle, } from '../bundle/four-meme/core.js';
+export { fourPrivateBuyMerkle, fourPrivateSellMerkle, fourBatchPrivateBuyMerkle, fourBatchPrivateSellMerkle, openFourBatchBuyByBudgetMerkle, } 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';
@@ -22,6 +22,8 @@ export { fourPancakeProxyBatchBuyMerkle, fourPancakeProxyBatchSellMerkle, approv
 export { approveFourTokenManagerBatch } from '../bundle/four-meme/approve-tokenmanager.js';
 export { submitBundleToMerkle, submitMultipleBundles, submitMultipleBundlesParallel, submitBundleToBlockRazor, submitMultipleBundlesToBlockRazor, submitMultipleBundlesToBlockRazorParallel, type MerkleSubmitConfig, type SubmitBundleResult, type BlockRazorSubmitConfig, type BlockRazorSubmitResult, } from '../bundle/submit.js';
 export type { FourBundleMerkleConfig, FourSignConfig, FourCreateWithBundleBuySignParams, FourBatchBuySignParams, FourBatchSellSignParams, FourPrivateBuySignParams, FourPrivateSellSignParams, FourBatchPrivateBuySignParams, FourBatchPrivateSellSignParams, FourPancakeProxyBatchBuySignParams, FourPancakeProxyBatchSellSignParams, DisperseSignParams as FourDisperseSignParams, SweepSignParams as FourSweepSignParams, FourCreateWithBundleBuyMerkleParams, FourCreateWithBundleBuyMerkleResult, FourBatchBuyMerkleParams, FourBatchBuyMerkleResult, FourBatchSellMerkleParams, FourBatchSellMerkleResult, FourPrivateBuyMerkleParams, FourPrivateSellMerkleParams, FourBatchPrivateBuyMerkleParams, FourBatchPrivateSellMerkleParams, FourBatchPrivateMerkleResult, FourPrivateTransactionResult, DisperseMerkleParams, DisperseMerkleResult, SweepMerkleParams, SweepMerkleResult, FourPancakeProxyBatchBuyParams, FourPancakeProxyBatchBuyResult, FourPancakeProxyBatchSellParams, FourPancakeProxyBatchSellResult, FourPancakeProxyApprovalParams, FourPancakeProxyApprovalBatchParams, FourPancakeProxyApprovalBatchResult, ApproveFourTokenManagerBatchParams, ApproveFourTokenManagerBatchResult, } from '../bundle/four-meme/types/index.js';
+export type { OpenFourCreateSignParams } from '../bundle/four-meme/core.js';
+export type { OpenFourBatchBuySignParams } from '../bundle/four-meme/private.js';
 export { isTaxToken as fourIsTaxToken, isAntiSniperFeeMode as fourIsAntiSniperFeeMode, getCreatorType as fourGetCreatorType, getTaxTokenInfo as fourGetTaxTokenInfo, getClaimableFee as fourGetClaimableFee, getClaimedFee as fourGetClaimedFee, getUserRewardInfo as fourGetUserRewardInfo, buildClaimFeeTx as fourBuildClaimFeeTx, buildBatchClaimFeeTxs as fourBuildBatchClaimFeeTxs, validateFourTokenTaxInfo, TAX_TOKEN_ABI, TransferMode as FourTransferMode, type TaxTokenConfig as FourTaxTokenConfig, type TaxTokenRewardStats as FourTaxTokenRewardStats, type TaxTokenUserInfo as FourTaxTokenUserInfo, type TaxTokenInfo as FourTaxTokenInfo, } from '../domains/four/index.js';
 export { PinataClient, type PinataConfig } from '../domains/flap/pinata.js';
 export { pinFileToIPFSWithJWT, pinImageByPath, pinFileToIPFSWithJWTWeb, pinDataURLWithJWTWeb, dataURLToBlob, type PinataPinResp, } from '../domains/flap/pinata.js';

package/dist/exports/root-bundle-and-tooling.js

@@ -13,8 +13,8 @@ export { createTokenWithBundleBuy as flapCreateTokenWithBundleBuy, batchBuyWithB
 export { fourPrivateBuy, fourPrivateSell, fourBatchPrivateBuy, fourBatchPrivateSell, } from '../domains/four/contracts/tm-bundle.js';
 export { flapPrivateBuy, flapPrivateSell, flapBatchPrivateBuy, flapBatchPrivateSell, } from '../domains/flap/portal-bundle.js';
 export { createTokenWithBundleBuyMerkle as flapCreateTokenWithBundleBuyMerkle, batchBuyWithBundleMerkle as flapBatchBuyWithBundleMerkle, batchSellWithBundleMerkle as flapBatchSellWithBundleMerkle, flapPrivateBuyMerkle, flapPrivateSellMerkle, flapBatchPrivateBuyMerkle, flapBatchPrivateSellMerkle, pancakeProxyBatchBuyMerkle, pancakeProxyBatchSellMerkle, approvePancakeProxy, approvePancakeProxyBatch, flapDisperseWithBundleMerkle, flapSweepWithBundleMerkle, } from '../domains/flap/portal-bundle-merkle/index.js';
-export { createTokenWithBundleBuyMerkle as fourCreateTokenWithBundleBuyMerkle, batchBuyWithBundleMerkle as fourBatchBuyWithBundleMerkle, batchSellWithBundleMerkle as fourBatchSellWithBundleMerkle, } from '../bundle/four-meme/core.js';
-export { fourPrivateBuyMerkle, fourPrivateSellMerkle, fourBatchPrivateBuyMerkle, fourBatchPrivateSellMerkle, } from '../bundle/four-meme/private.js';
+export { createTokenWithBundleBuyMerkle as fourCreateTokenWithBundleBuyMerkle, createOpenFourTokenMerkle as fourCreateOpenFourTokenMerkle, batchBuyWithBundleMerkle as fourBatchBuyWithBundleMerkle, batchSellWithBundleMerkle as fourBatchSellWithBundleMerkle, } from '../bundle/four-meme/core.js';
+export { fourPrivateBuyMerkle, fourPrivateSellMerkle, fourBatchPrivateBuyMerkle, fourBatchPrivateSellMerkle, openFourBatchBuyByBudgetMerkle, } 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';

package/dist/exports/root-foundations.d.ts

@@ -14,7 +14,9 @@ export { isExclusiveOnChain, isExclusiveOffChain } from '../utils/mpcExclusive.j
 export { ensureSellApprovalV1, checkSellApprovalV1, ensureSellApprovalV2, checkSellApprovalV2, ensureSellApproval, checkSellApproval, ensureFlapSellApproval, checkFlapSellApproval, ensureFlapSellApprovalBatch, checkFlapSellApprovalBatch, checkAllowance, approveToken, checkAllowanceBatch, approveTokenBatch, checkAllowanceRaw, approveTokenRaw, checkAllowanceBatchRaw, approveTokenBatchRaw, } from '../core/erc20/index.js';
 export { parseFourError, type FourErrorCode } from '../utils/errors.js';
 export { getTokenManagerV1, getTokenManagerV2, getTokenManagerHelper3, getTokenManagerV1Writer, getTokenManagerV2Writer, getTokenManagerHelper3Writer, getTokenManagerAddress, type ChainName, } from '../utils/contract-factory.js';
-export { FourClient, buildLoginMessage, type FourConfig, type GenerateNonceReq, type LoginReq, type CreateTokenReq, type CreateTokenResp, type FourTokenTaxInfo, } from '../core/clients/four.js';
+export { FourClient, buildLoginMessage, buildCreateTokenReq, type FourConfig, type GenerateNonceReq, type LoginReq, type CreateTokenReq, type CreateTokenCustom, type CreateTokenResp, type FourTokenTaxInfo, type FourRaisedToken, type FourTokenLabel, } from '../core/clients/four.js';
+export { collectOpenFourSchemaParams, computeOpenFourCreateValueWei, decodeOpenFourCreateArg, defaultOpenFourFormFromSchema, emptyOpenFourInitParams, encodeOpenFourInitParams, encodeOpenFourModuleParams, isOpenFourPresaleNative, loadOpenFourAddresses, loadOpenFourPresetSchemas, type OpenFourAddresses, type OpenFourCreateReq, type OpenFourDecodedCreateArg, type OpenFourInitParams, type OpenFourModuleSchema, type OpenFourParamDescriptor, type OpenFourPresetSchemas, type OpenFourTemplate, type OpenFourTemplateConfig, } from '../domains/openfour/index.js';
+export { FOUR_TOKEN_LABELS, FOUR_BNB_RAISED_TOKEN_FALLBACK, parseRaisedTokens, publishedRaisedTokens, pickRaisedToken, isNativeRaisedToken, computeFourCreateValueWei, raisedTokenTradingFeeBps, } from '../domains/four/raised-token.js';
 export { createTokenOnChain, tryBuy, trySell, buyTokenWithFunds, sellToken, tradeBuy, tradeSell, type CreateOnChainParams, type TryBuyResult, type TrySellResult, } from '../domains/four/contracts/tm.js';
 export { TM1, type FourChainV1 } from '../domains/four/contracts/tm1.js';
 export { TM2, type FourChainV2 } from '../domains/four/contracts/tm2.js';

package/dist/exports/root-foundations.js

@@ -49,7 +49,9 @@ checkAllowance, approveToken, checkAllowanceBatch, approveTokenBatch,
 checkAllowanceRaw, approveTokenRaw, checkAllowanceBatchRaw, approveTokenBatchRaw, } from '../core/erc20/index.js';
 export { parseFourError } from '../utils/errors.js';
 export { getTokenManagerV1, getTokenManagerV2, getTokenManagerHelper3, getTokenManagerV1Writer, getTokenManagerV2Writer, getTokenManagerHelper3Writer, getTokenManagerAddress, } from '../utils/contract-factory.js';
-export { FourClient, buildLoginMessage, } from '../core/clients/four.js';
+export { FourClient, buildLoginMessage, buildCreateTokenReq, } from '../core/clients/four.js';
+export { collectOpenFourSchemaParams, computeOpenFourCreateValueWei, decodeOpenFourCreateArg, defaultOpenFourFormFromSchema, emptyOpenFourInitParams, encodeOpenFourInitParams, encodeOpenFourModuleParams, isOpenFourPresaleNative, loadOpenFourAddresses, loadOpenFourPresetSchemas, } from '../domains/openfour/index.js';
+export { FOUR_TOKEN_LABELS, FOUR_BNB_RAISED_TOKEN_FALLBACK, parseRaisedTokens, publishedRaisedTokens, pickRaisedToken, isNativeRaisedToken, computeFourCreateValueWei, raisedTokenTradingFeeBps, } from '../domains/four/raised-token.js';
 export { createTokenOnChain, tryBuy, trySell, buyTokenWithFunds, sellToken, tradeBuy, tradeSell, } from '../domains/four/contracts/tm.js';
 export { TM1 } from '../domains/four/contracts/tm1.js';
 export { TM2 } from '../domains/four/contracts/tm2.js';

package/package.json

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