four-flap-meme-sdk 4.1.0 → 4.2.0

package/dist/chains/robinhood/longetf/launch.js

@@ -0,0 +1,64 @@
+/**
+ * LONGETF 三步发币：deployVault → long.xyz create() → register
+ * 必须逐笔等确认，不能一次签完再广播。
+ */
+import { JsonRpcProvider } from 'ethers';
+import { LONGETF_DEPLOY_VAULT_GAS_LIMIT, LONGETF_FACTORY, LONGETF_LAUNCH_GAS_LIMIT, LONGETF_REGISTER_GAS_LIMIT, LONG_XYZ_LAUNCHER, ROBINHOOD_CHAIN_ID, ROBINHOOD_RPC_URL, } from '../constants.js';
+import { signRobinhoodTx } from '../sign.js';
+import { LONGETF_VAULT_INITCODE } from './assets.js';
+import { encodeLongetfDeployVault, encodeLongetfIsTickerAvailable, encodeLongetfRegister, longetfVaultInitCodeHash, mineLongetfVaultSalt, patchLongetfLaunchCalldata, } from './encode.js';
+export async function isLongetfTickerAvailable(ticker, rpcUrl = ROBINHOOD_RPC_URL) {
+    const provider = new JsonRpcProvider(rpcUrl, ROBINHOOD_CHAIN_ID, { staticNetwork: true });
+    const data = encodeLongetfIsTickerAvailable(ticker);
+    const out = await provider.call({ to: LONG_XYZ_LAUNCHER, data });
+    return BigInt(out) === 1n;
+}
+export function prepareLongetfVault(creator, vaultInitCode) {
+    return mineLongetfVaultSalt(creator, {
+        initCodeHash: vaultInitCode ? longetfVaultInitCodeHash(vaultInitCode) : undefined,
+    });
+}
+export async function signLongetfDeployVault(params) {
+    const initCode = params.vaultInitCode ?? LONGETF_VAULT_INITCODE;
+    return signRobinhoodTx({
+        rpcUrl: params.rpcUrl,
+        privateKey: params.privateKey,
+        to: LONGETF_FACTORY,
+        data: encodeLongetfDeployVault(params.salt, params.creator, initCode),
+        gasLimit: LONGETF_DEPLOY_VAULT_GAS_LIMIT,
+        gasPrice: params.gasPrice,
+        nonce: params.nonce,
+    });
+}
+export async function signLongetfLaunch(params) {
+    return signRobinhoodTx({
+        rpcUrl: params.rpcUrl,
+        privateKey: params.privateKey,
+        to: LONG_XYZ_LAUNCHER,
+        data: patchLongetfLaunchCalldata({
+            name: params.name,
+            symbol: params.symbol,
+            anchor: params.anchor,
+            vault: params.vault,
+            metaUri: params.metaUri,
+        }, params.launchTemplate),
+        gasLimit: LONGETF_LAUNCH_GAS_LIMIT,
+        gasPrice: params.gasPrice,
+        nonce: params.nonce,
+    });
+}
+export async function signLongetfRegister(params) {
+    return signRobinhoodTx({
+        rpcUrl: params.rpcUrl,
+        privateKey: params.privateKey,
+        to: LONGETF_FACTORY,
+        data: encodeLongetfRegister(params.token, params.vault),
+        gasLimit: LONGETF_REGISTER_GAS_LIMIT,
+        gasPrice: params.gasPrice,
+        nonce: params.nonce,
+    });
+}
+export async function getLongetfVaultCode(vault, rpcUrl = ROBINHOOD_RPC_URL) {
+    const provider = new JsonRpcProvider(rpcUrl, ROBINHOOD_CHAIN_ID, { staticNetwork: true });
+    return provider.getCode(vault);
+}

package/dist/chains/robinhood/pons-v2/encode.d.ts

@@ -0,0 +1,62 @@
+/**
+ * pons v2 发币编码
+ *
+ * 对齐 https://docs.ponsfamily.com/v2：launchToken / launchAndBuy。
+ */
+export declare const PONS_V2_TOKEN_LAUNCHED_TOPIC: string;
+export interface PonsV2Socials {
+    twitter: string;
+    telegram: string;
+    discord: string;
+    website: string;
+    farcaster: string;
+}
+export interface PonsV2TokenParams {
+    name: string;
+    symbol: string;
+    logo?: string;
+    description?: string;
+    socials?: Partial<PonsV2Socials>;
+    creatorFeeRecipient?: string;
+    creatorTaxBps?: number;
+    buybackEnabled?: boolean;
+    expectedEconomics: string;
+    salt?: string;
+}
+export interface PonsV2LaunchCall {
+    to: string;
+    data: string;
+    value: bigint;
+}
+export declare function randomPonsV2Salt(): string;
+export declare function toPonsV2TokenTuple(params: PonsV2TokenParams, options?: {
+    requireCreatorFeeRecipient?: boolean;
+}): {
+    name: string;
+    symbol: string;
+    logo: string;
+    description: string;
+    socials: PonsV2Socials;
+    creatorFeeRecipient: string;
+    creatorTaxBps: number;
+    buybackEnabled: boolean;
+    expectedEconomics: string;
+    salt: string;
+};
+export declare function encodePonsV2LaunchToken(params: PonsV2TokenParams, launchConfigId: bigint, pairToken?: string, snipeTaxExemptions?: string[]): string;
+export declare function encodePonsV2LaunchAndBuy(params: PonsV2TokenParams, launchConfigId: bigint, pairToken: string, quoteIn: bigint, minTokensOut: bigint, recipient: string, snipeTaxExemptions?: string[]): string;
+export declare function encodePonsV2PreviewLaunchEconomics(launchConfigId: bigint, pairToken: string): string;
+export declare function parsePonsV2TokenFromLogs(logs: ReadonlyArray<{
+    topics: readonly string[];
+    address: string;
+}>, factory?: string): string | undefined;
+export declare function buildPonsV2LaunchCall(params: {
+    token: PonsV2TokenParams;
+    launchConfigId: bigint;
+    pairToken?: string;
+    launchFee: bigint;
+    quoteIn?: bigint;
+    minTokensOut?: bigint;
+    recipient?: string;
+    snipeTaxExemptions?: string[];
+}): PonsV2LaunchCall;

package/dist/chains/robinhood/pons-v2/encode.js

@@ -0,0 +1,115 @@
+/**
+ * pons v2 发币编码
+ *
+ * 对齐 https://docs.ponsfamily.com/v2：launchToken / launchAndBuy。
+ */
+import { getAddress, hexlify, id, Interface, randomBytes, ZeroAddress } from 'ethers';
+import { PONS_V2_FACTORY, PONS_V2_LAUNCH_AND_BUY, PONS_V2_LAUNCH_AND_BUY_ABI } from '../constants.js';
+const SOCIALS_TUPLE = 'tuple(string twitter, string telegram, string discord, string website, string farcaster)';
+const TOKEN_PARAMS_TUPLE = `tuple(string name, string symbol, string logo, string description, ${SOCIALS_TUPLE} socials, address creatorFeeRecipient, uint16 creatorTaxBps, bool buybackEnabled, bytes32 expectedEconomics, bytes32 salt)`;
+const launchTokenIface = new Interface([
+    `function launchToken(${TOKEN_PARAMS_TUPLE} params, uint256 launchConfigId, address pairToken) payable returns (address token, address curve)`,
+]);
+const launchTokenExemptIface = new Interface([
+    `function launchToken(${TOKEN_PARAMS_TUPLE} params, uint256 launchConfigId, address pairToken, address[] snipeTaxExemptions) payable returns (address token, address curve)`,
+]);
+const previewIface = new Interface([
+    'function previewLaunchEconomics(uint256 launchConfigId, address pairToken) view returns (bytes32)',
+]);
+const launchAndBuyIface = new Interface(PONS_V2_LAUNCH_AND_BUY_ABI);
+export const PONS_V2_TOKEN_LAUNCHED_TOPIC = id('TokenLaunched(address,address,address,address,uint256,uint256)');
+function emptySocials() {
+    return { twitter: '', telegram: '', discord: '', website: '', farcaster: '' };
+}
+export function randomPonsV2Salt() {
+    return hexlify(randomBytes(32));
+}
+export function toPonsV2TokenTuple(params, options) {
+    const recipient = params.creatorFeeRecipient?.trim()
+        ? getAddress(params.creatorFeeRecipient)
+        : ZeroAddress;
+    if (options?.requireCreatorFeeRecipient && recipient === ZeroAddress) {
+        throw new Error('pons launchAndBuy requires an explicit creatorFeeRecipient');
+    }
+    const socials = { ...emptySocials(), ...params.socials };
+    return {
+        name: params.name,
+        symbol: params.symbol,
+        logo: params.logo ?? '',
+        description: params.description ?? '',
+        socials,
+        creatorFeeRecipient: recipient,
+        creatorTaxBps: params.creatorTaxBps ?? 0,
+        buybackEnabled: params.buybackEnabled ?? true,
+        expectedEconomics: params.expectedEconomics,
+        salt: params.salt ?? randomPonsV2Salt(),
+    };
+}
+export function encodePonsV2LaunchToken(params, launchConfigId, pairToken = ZeroAddress, snipeTaxExemptions) {
+    const tuple = toPonsV2TokenTuple(params);
+    const pair = pairToken === ZeroAddress ? ZeroAddress : getAddress(pairToken);
+    if (snipeTaxExemptions && snipeTaxExemptions.length > 0) {
+        if (snipeTaxExemptions.length > 32) {
+            throw new Error('pons snipe tax exemption list exceeds 32');
+        }
+        return launchTokenExemptIface.encodeFunctionData('launchToken', [
+            tuple,
+            launchConfigId,
+            pair,
+            snipeTaxExemptions.map((a) => getAddress(a)),
+        ]);
+    }
+    return launchTokenIface.encodeFunctionData('launchToken', [tuple, launchConfigId, pair]);
+}
+export function encodePonsV2LaunchAndBuy(params, launchConfigId, pairToken, quoteIn, minTokensOut, recipient, snipeTaxExemptions = []) {
+    const tuple = toPonsV2TokenTuple(params, { requireCreatorFeeRecipient: true });
+    const pair = pairToken === ZeroAddress ? ZeroAddress : getAddress(pairToken);
+    if (snipeTaxExemptions.length > 32) {
+        throw new Error('pons snipe tax exemption list exceeds 32');
+    }
+    return launchAndBuyIface.encodeFunctionData('launchAndBuy', [
+        tuple,
+        launchConfigId,
+        pair,
+        quoteIn,
+        minTokensOut,
+        getAddress(recipient),
+        snipeTaxExemptions.map((a) => getAddress(a)),
+    ]);
+}
+export function encodePonsV2PreviewLaunchEconomics(launchConfigId, pairToken) {
+    const pair = pairToken === ZeroAddress ? ZeroAddress : getAddress(pairToken);
+    return previewIface.encodeFunctionData('previewLaunchEconomics', [launchConfigId, pair]);
+}
+export function parsePonsV2TokenFromLogs(logs, factory = PONS_V2_FACTORY) {
+    const factoryAddr = getAddress(factory);
+    for (const log of logs) {
+        if (log.topics[0] !== PONS_V2_TOKEN_LAUNCHED_TOPIC || log.topics.length < 2)
+            continue;
+        if (getAddress(log.address) !== factoryAddr && getAddress(log.address) !== getAddress(PONS_V2_LAUNCH_AND_BUY)) {
+            // TokenLaunched is emitted by the factory; router path still originates there.
+        }
+        return getAddress(`0x${log.topics[1].slice(26)}`);
+    }
+    return undefined;
+}
+export function buildPonsV2LaunchCall(params) {
+    const pairToken = params.pairToken ?? ZeroAddress;
+    const quoteIn = params.quoteIn ?? 0n;
+    if (quoteIn > 0n) {
+        if (!params.recipient) {
+            throw new Error('pons launchAndBuy needs a recipient');
+        }
+        const nativePair = pairToken === ZeroAddress;
+        return {
+            to: PONS_V2_LAUNCH_AND_BUY,
+            data: encodePonsV2LaunchAndBuy(params.token, params.launchConfigId, pairToken, quoteIn, params.minTokensOut ?? 0n, params.recipient, params.snipeTaxExemptions ?? []),
+            value: nativePair ? params.launchFee + quoteIn : params.launchFee,
+        };
+    }
+    return {
+        to: PONS_V2_FACTORY,
+        data: encodePonsV2LaunchToken(params.token, params.launchConfigId, pairToken, params.snipeTaxExemptions),
+        value: params.launchFee,
+    };
+}

package/dist/chains/robinhood/pons-v2/index.d.ts

@@ -0,0 +1,2 @@
+export { PONS_V2_TOKEN_LAUNCHED_TOPIC, randomPonsV2Salt, toPonsV2TokenTuple, encodePonsV2LaunchToken, encodePonsV2LaunchAndBuy, encodePonsV2PreviewLaunchEconomics, parsePonsV2TokenFromLogs, buildPonsV2LaunchCall, type PonsV2Socials, type PonsV2TokenParams, type PonsV2LaunchCall, } from './encode.js';
+export { getPonsV2LaunchFee, previewPonsV2LaunchEconomics, canPonsV2Launch, listOpenPonsV2LaunchConfigs, signPonsV2Launch, type PonsV2LaunchConfig, type PonsV2LaunchParams, type PonsV2LaunchSignResult, } from './launch.js';

package/dist/chains/robinhood/pons-v2/index.js

@@ -0,0 +1,2 @@
+export { PONS_V2_TOKEN_LAUNCHED_TOPIC, randomPonsV2Salt, toPonsV2TokenTuple, encodePonsV2LaunchToken, encodePonsV2LaunchAndBuy, encodePonsV2PreviewLaunchEconomics, parsePonsV2TokenFromLogs, buildPonsV2LaunchCall, } from './encode.js';
+export { getPonsV2LaunchFee, previewPonsV2LaunchEconomics, canPonsV2Launch, listOpenPonsV2LaunchConfigs, signPonsV2Launch, } from './launch.js';

package/dist/chains/robinhood/pons-v2/launch.d.ts

@@ -0,0 +1,48 @@
+/**
+ * pons v2 发币：读 launchFee + expectedEconomics，再签 launchToken 或 launchAndBuy
+ */
+import { type RobinhoodSignedTx } from '../sign.js';
+export interface PonsV2LaunchConfig {
+    id: bigint;
+    supply: bigint;
+    curveFeeBps: bigint;
+    phantomQuote: bigint;
+    graduationThreshold: bigint;
+    poolFee: number;
+    tickSpacing: number;
+    enabled: boolean;
+}
+export interface PonsV2LaunchParams {
+    rpcUrl?: string;
+    privateKey: string;
+    name: string;
+    symbol: string;
+    logo?: string;
+    description?: string;
+    twitter?: string;
+    telegram?: string;
+    website?: string;
+    creatorFeeRecipient?: string;
+    creatorTaxBps?: number;
+    buybackEnabled?: boolean;
+    launchConfigId?: bigint;
+    pairToken?: string;
+    quoteIn?: bigint;
+    minTokensOut?: bigint;
+    snipeTaxExemptions?: string[];
+    salt?: string;
+    gasPrice?: bigint;
+    nonce?: number;
+}
+export interface PonsV2LaunchSignResult extends RobinhoodSignedTx {
+    launchFee: bigint;
+    expectedEconomics: string;
+    salt: string;
+    to: string;
+    value: bigint;
+}
+export declare function getPonsV2LaunchFee(rpcUrl?: string): Promise<bigint>;
+export declare function previewPonsV2LaunchEconomics(launchConfigId: bigint, pairToken?: string, rpcUrl?: string): Promise<string>;
+export declare function canPonsV2Launch(account: string, rpcUrl?: string): Promise<boolean>;
+export declare function listOpenPonsV2LaunchConfigs(rpcUrl?: string): Promise<PonsV2LaunchConfig[]>;
+export declare function signPonsV2Launch(params: PonsV2LaunchParams): Promise<PonsV2LaunchSignResult>;

package/dist/chains/robinhood/pons-v2/launch.js

@@ -0,0 +1,107 @@
+/**
+ * pons v2 发币：读 launchFee + expectedEconomics，再签 launchToken 或 launchAndBuy
+ */
+import { Contract, JsonRpcProvider, Wallet, ZeroAddress } from 'ethers';
+import { PONS_V2_FACTORY, PONS_V2_FACTORY_ABI, PONS_V2_LAUNCH_GAS_LIMIT, ROBINHOOD_CHAIN_ID, ROBINHOOD_RPC_URL, } from '../constants.js';
+import { signRobinhoodTx } from '../sign.js';
+import { buildPonsV2LaunchCall, encodePonsV2PreviewLaunchEconomics, randomPonsV2Salt, } from './encode.js';
+export async function getPonsV2LaunchFee(rpcUrl = ROBINHOOD_RPC_URL) {
+    const provider = new JsonRpcProvider(rpcUrl, ROBINHOOD_CHAIN_ID, { staticNetwork: true });
+    const factory = new Contract(PONS_V2_FACTORY, PONS_V2_FACTORY_ABI, provider);
+    return factory.launchFee();
+}
+export async function previewPonsV2LaunchEconomics(launchConfigId, pairToken = ZeroAddress, rpcUrl = ROBINHOOD_RPC_URL) {
+    const provider = new JsonRpcProvider(rpcUrl, ROBINHOOD_CHAIN_ID, { staticNetwork: true });
+    const data = encodePonsV2PreviewLaunchEconomics(launchConfigId, pairToken);
+    return provider.call({ to: PONS_V2_FACTORY, data });
+}
+export async function canPonsV2Launch(account, rpcUrl = ROBINHOOD_RPC_URL) {
+    const provider = new JsonRpcProvider(rpcUrl, ROBINHOOD_CHAIN_ID, { staticNetwork: true });
+    const factory = new Contract(PONS_V2_FACTORY, PONS_V2_FACTORY_ABI, provider);
+    return factory.canLaunch(account);
+}
+export async function listOpenPonsV2LaunchConfigs(rpcUrl = ROBINHOOD_RPC_URL) {
+    const provider = new JsonRpcProvider(rpcUrl, ROBINHOOD_CHAIN_ID, { staticNetwork: true });
+    const factory = new Contract(PONS_V2_FACTORY, PONS_V2_FACTORY_ABI, provider);
+    const count = Number(await factory.launchConfigCount());
+    const configs = [];
+    for (let id = 0; id < count; id++) {
+        const row = (await factory.getLaunchConfig(BigInt(id)));
+        const enabled = Boolean(row.enabled);
+        if (!enabled)
+            continue;
+        configs.push({
+            id: BigInt(id),
+            supply: row.supply,
+            curveFeeBps: row.curveFeeBps,
+            phantomQuote: row.phantomQuote,
+            graduationThreshold: row.graduationThreshold,
+            poolFee: Number(row.poolFee),
+            tickSpacing: Number(row.tickSpacing),
+            enabled,
+        });
+    }
+    return configs;
+}
+export async function signPonsV2Launch(params) {
+    const rpcUrl = params.rpcUrl ?? ROBINHOOD_RPC_URL;
+    const wallet = new Wallet(params.privateKey);
+    const pairToken = params.pairToken ?? ZeroAddress;
+    const launchConfigId = params.launchConfigId ?? 0n;
+    const salt = params.salt ?? randomPonsV2Salt();
+    const creatorFeeRecipient = params.creatorFeeRecipient?.trim()
+        ? params.creatorFeeRecipient
+        : wallet.address;
+    const allowed = await canPonsV2Launch(wallet.address, rpcUrl);
+    if (!allowed) {
+        throw new Error('pons factory is not allowing this wallet to launch');
+    }
+    const [launchFee, expectedEconomics] = await Promise.all([
+        getPonsV2LaunchFee(rpcUrl),
+        previewPonsV2LaunchEconomics(launchConfigId, pairToken, rpcUrl),
+    ]);
+    const token = {
+        name: params.name,
+        symbol: params.symbol,
+        logo: params.logo,
+        description: params.description,
+        socials: {
+            twitter: params.twitter ?? '',
+            telegram: params.telegram ?? '',
+            website: params.website ?? '',
+        },
+        creatorFeeRecipient,
+        creatorTaxBps: params.creatorTaxBps,
+        buybackEnabled: params.buybackEnabled,
+        expectedEconomics,
+        salt,
+    };
+    const call = buildPonsV2LaunchCall({
+        token,
+        launchConfigId,
+        pairToken,
+        launchFee,
+        quoteIn: params.quoteIn,
+        minTokensOut: params.minTokensOut,
+        recipient: wallet.address,
+        snipeTaxExemptions: params.snipeTaxExemptions,
+    });
+    const signed = await signRobinhoodTx({
+        rpcUrl,
+        privateKey: params.privateKey,
+        to: call.to,
+        data: call.data,
+        value: call.value,
+        gasLimit: PONS_V2_LAUNCH_GAS_LIMIT,
+        gasPrice: params.gasPrice,
+        nonce: params.nonce,
+    });
+    return {
+        ...signed,
+        launchFee,
+        expectedEconomics,
+        salt,
+        to: call.to,
+        value: call.value,
+    };
+}

package/dist/chains/robinhood/robinhood.test.d.ts

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

package/dist/chains/robinhood/robinhood.test.js

@@ -0,0 +1,103 @@
+import { id, Interface, keccak256, toUtf8Bytes, ZeroAddress } from 'ethers';
+import { describe, expect, it } from 'vitest';
+import { ADDRESSES, CHAINS, isRobinhoodChain } from '../../core/constants/index.js';
+import { encodeLongetfDeployVault, encodeLongetfRegister, longetfEffectiveSalt, longetfVaultInitCodeHash, mineLongetfVaultSalt, parseLongetfTokenFromLogs, patchLongetfLaunchCalldata, predictLongetfVault, } from './longetf/encode.js';
+import { LONGETF_LAUNCH_TEMPLATE } from './longetf/assets.js';
+import { encodePonsV2LaunchAndBuy, encodePonsV2LaunchToken, parsePonsV2TokenFromLogs, PONS_V2_TOKEN_LAUNCHED_TOPIC, } from './pons-v2/encode.js';
+import { LONGETF_FACTORY, LONG_XYZ_PROTOCOL_BENEFICIARY, PONS_V2_FACTORY, PONS_V2_LAUNCH_AND_BUY, } from './constants.js';
+describe('Robinhood LONGETF / pons v2 launch encoding', () => {
+    const creator = '0x1111111111111111111111111111111111111111';
+    it('exposes Robinhood chain id 4663', () => {
+        expect(CHAINS.ROBINHOOD.chainId).toBe(4663);
+        expect(isRobinhoodChain(4663)).toBe(true);
+        expect(ADDRESSES.ROBINHOOD.LongetfFactory.toLowerCase()).toBe(LONGETF_FACTORY.toLowerCase());
+    });
+    it('mines a vault that sorts above the long.xyz protocol beneficiary', () => {
+        const mined = mineLongetfVaultSalt(creator);
+        expect(predictLongetfVault(mined.salt, creator)).toBe(mined.vault);
+        expect(BigInt(mined.vault) > BigInt(LONG_XYZ_PROTOCOL_BENEFICIARY)).toBe(true);
+        expect(longetfEffectiveSalt(mined.salt, creator)).toMatch(/^0x[0-9a-f]{64}$/);
+        expect(longetfVaultInitCodeHash()).toMatch(/^0x[0-9a-f]{64}$/);
+    });
+    it('encodes deployVault / register with the live selectors', () => {
+        const salt = '0x' + '11'.repeat(32);
+        const deploy = encodeLongetfDeployVault(salt, creator);
+        expect(deploy.slice(0, 10)).toBe(id('deployVault(bytes32,address,bytes)').slice(0, 10));
+        const token = '0x2222222221111111111111111111111111111111';
+        const register = encodeLongetfRegister(token, creator);
+        expect(register.slice(0, 10)).toBe(id('register(address,address)').slice(0, 10));
+    });
+    it('patches long.xyz create() template name, ticker, anchor and vault', () => {
+        const vault = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+        const anchor = '0xaf3d76f1834a1d425780943c99ea8a608f8a93f9';
+        const data = patchLongetfLaunchCalldata({
+            name: 'TestCoin',
+            symbol: 'HOOD',
+            anchor,
+            vault,
+            metaUri: '',
+            launchSalt: '0x' + '22'.repeat(32),
+        });
+        expect(data.startsWith('0x882db707')).toBe(true);
+        expect(data.length).toBe(LONGETF_LAUNCH_TEMPLATE.length);
+        expect(data.toLowerCase()).toContain(vault.slice(2).toLowerCase());
+        expect(data.toLowerCase()).toContain(anchor.slice(2).toLowerCase());
+        expect(data).toContain('484f4f44');
+    });
+    it('rejects illegal LONGETF tickers', () => {
+        expect(() => patchLongetfLaunchCalldata({
+            name: 'X',
+            symbol: 'H00D',
+            anchor: creator,
+            vault: creator,
+        })).toThrow(/letters only/i);
+    });
+    it('parses a mint Transfer as the LONGETF token', () => {
+        const token = '0x3333333333333333333333333333333333333333';
+        const topic = keccak256(toUtf8Bytes('Transfer(address,address,uint256)'));
+        const parsed = parseLongetfTokenFromLogs([
+            {
+                address: token,
+                topics: [topic, '0x' + '00'.repeat(32), '0x' + creator.slice(2).padStart(64, '0')],
+            },
+        ]);
+        expect(parsed?.toLowerCase()).toBe(token);
+    });
+    it('encodes pons v2 launchToken and launchAndBuy', () => {
+        const economics = '0x' + 'ab'.repeat(32);
+        const launch = encodePonsV2LaunchToken({
+            name: 'Example',
+            symbol: 'EXMPL',
+            expectedEconomics: economics,
+            salt: '0x' + '33'.repeat(32),
+        }, 0n, ZeroAddress);
+        expect(launch.startsWith('0x')).toBe(true);
+        expect(launch.length).toBeGreaterThan(10);
+        const buy = encodePonsV2LaunchAndBuy({
+            name: 'Example',
+            symbol: 'EXMPL',
+            expectedEconomics: economics,
+            salt: '0x' + '33'.repeat(32),
+            creatorFeeRecipient: creator,
+        }, 0n, ZeroAddress, 10n ** 16n, 0n, creator, []);
+        expect(buy.startsWith('0x')).toBe(true);
+        expect(PONS_V2_LAUNCH_AND_BUY.toLowerCase()).toMatch(/^0x[0-9a-f]{40}$/);
+        expect(PONS_V2_FACTORY.toLowerCase()).toMatch(/^0x[0-9a-f]{40}$/);
+    });
+    it('requires creatorFeeRecipient on launchAndBuy', () => {
+        expect(() => encodePonsV2LaunchAndBuy({ name: 'A', symbol: 'B', expectedEconomics: '0x' + '00'.repeat(32) }, 0n, ZeroAddress, 1n, 0n, creator)).toThrow(/creatorFeeRecipient/);
+    });
+    it('parses TokenLaunched topic0 as the pons token', () => {
+        const token = '0x4444444444444444444444444444444444444444';
+        const parsed = parsePonsV2TokenFromLogs([
+            {
+                address: PONS_V2_FACTORY,
+                topics: [PONS_V2_TOKEN_LAUNCHED_TOPIC, '0x' + token.slice(2).padStart(64, '0')],
+            },
+        ]);
+        expect(parsed?.toLowerCase()).toBe(token);
+        expect(PONS_V2_TOKEN_LAUNCHED_TOPIC).toBe(new Interface([
+            'event TokenLaunched(address indexed token, address indexed curve, address indexed deployer, address pairToken, uint256 launchConfigId, uint256 graduationThreshold)',
+        ]).getEvent('TokenLaunched').topicHash);
+    });
+});

package/dist/chains/robinhood/sign.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Robinhood Chain EIP-1559 签名
+ */
+export interface RobinhoodSignParams {
+    rpcUrl?: string;
+    privateKey: string;
+    to: string;
+    data: string;
+    value?: bigint;
+    gasLimit: bigint;
+    gasPrice?: bigint;
+    nonce?: number;
+}
+export interface RobinhoodSignedTx {
+    signedTx: string;
+    from: string;
+    nonce: number;
+    hash: string;
+}
+export declare function signRobinhoodTx(params: RobinhoodSignParams): Promise<RobinhoodSignedTx>;

package/dist/chains/robinhood/sign.js

@@ -0,0 +1,31 @@
+/**
+ * Robinhood Chain EIP-1559 签名
+ */
+import { JsonRpcProvider, Transaction, Wallet } from 'ethers';
+import { ROBINHOOD_CHAIN_ID, ROBINHOOD_RPC_URL } from './constants.js';
+export async function signRobinhoodTx(params) {
+    const rpcUrl = params.rpcUrl ?? ROBINHOOD_RPC_URL;
+    const provider = new JsonRpcProvider(rpcUrl, ROBINHOOD_CHAIN_ID, { staticNetwork: true });
+    const wallet = new Wallet(params.privateKey, provider);
+    const nonce = params.nonce ?? (await wallet.getNonce());
+    const feeData = await provider.getFeeData();
+    const maxFeePerGas = params.gasPrice ?? feeData.maxFeePerGas ?? feeData.gasPrice ?? 1000000000n;
+    const signedTx = await wallet.signTransaction({
+        to: params.to,
+        value: params.value ?? 0n,
+        data: params.data,
+        nonce,
+        chainId: ROBINHOOD_CHAIN_ID,
+        type: 2,
+        maxFeePerGas,
+        maxPriorityFeePerGas: feeData.maxPriorityFeePerGas ?? 0n,
+        gasLimit: params.gasLimit,
+    });
+    const tx = Transaction.from(signedTx);
+    return {
+        signedTx,
+        from: wallet.address,
+        nonce,
+        hash: tx.hash ?? '',
+    };
+}

package/dist/chains/xlayer/eip7702/types-base.d.ts

@@ -0,0 +1,44 @@
+/**
+ * EIP-7702 XLayer 类型定义
+ */
+import { Wallet, HDNodeWallet } from 'ethers';
+/** 支持的钱包类型 */
+export type WalletType = Wallet | HDNodeWallet;
+/** 路由类型 */
+export type RouterType = 'V2' | 'V3';
+/** 交易类型 */
+export type TradeType = 'FLAP' | 'V2' | 'V3';
+/** 用户类型（用于利润计算） */
+export type UserType = 'v0' | 'v1' | 'default';
+export interface Authorization {
+    chainId: bigint;
+    address: string;
+    nonce: bigint;
+    yParity: number;
+    r: Uint8Array;
+    s: Uint8Array;
+}
+export interface Call3Value {
+    target: string;
+    allowFailure: boolean;
+    value: bigint;
+    callData: string;
+}
+export interface EIP7702Config {
+    /** RPC URL */
+    rpcUrl?: string;
+    /** Chain ID */
+    chainId?: number;
+    /** 代理合约地址 */
+    delegateAddress?: string;
+    /** Gas Limit */
+    gasLimit?: bigint;
+    /** 用户类型 */
+    userType?: UserType;
+    /** 利润接收地址（覆盖默认） */
+    profitRecipient?: string;
+}
+export interface GeneratedWallet {
+    address: string;
+    privateKey: string;
+}

package/dist/chains/xlayer/eip7702/types-base.js

@@ -0,0 +1,4 @@
+/**
+ * EIP-7702 XLayer 类型定义
+ */
+export {};