four-flap-meme-sdk 2.2.19 → 3.0.0

package/dist/core/gas/profit-hop.js

@@ -0,0 +1,72 @@
+import { Wallet } from 'ethers';
+import { generateWallets } from '../wallet/generate.js';
+import { GAS_LIMITS, CHAINS } from '../constants/index.js';
+import { NonceManager } from '../nonce/nonce-manager.js';
+import { buildGasFields } from './bundle-gas.js';
+export const PROFIT_HOP_COUNT = 2;
+const CHAINS_REQUIRE_HOP = [CHAINS.BSC.chainId];
+export async function buildProfitHopTransactions(config) {
+    const { provider, payerWallet, profitAmount, profitRecipient, hopCount = PROFIT_HOP_COUNT, gasPrice, chainId, txType, startNonce, } = config;
+    if (profitAmount <= 0n) {
+        return { signedTransactions: [], hopWallets: [], totalNonceUsed: 0 };
+    }
+    const nativeTransferGasLimit = GAS_LIMITS.NATIVE_TRANSFER;
+    const signedTxs = [];
+    const nonceManager = new NonceManager(provider);
+    const payerNonce = startNonce ?? (await nonceManager.getNextNonce(payerWallet));
+    const needHop = CHAINS_REQUIRE_HOP.includes(chainId);
+    const gasFields = buildGasFields(txType, gasPrice);
+    if (!needHop) {
+        const directTx = await payerWallet.signTransaction({
+            to: profitRecipient,
+            value: profitAmount,
+            nonce: payerNonce,
+            gasLimit: nativeTransferGasLimit,
+            chainId,
+            ...gasFields,
+        });
+        signedTxs.push(directTx);
+        return { signedTransactions: signedTxs, hopWallets: [], totalNonceUsed: 1 };
+    }
+    const gasFeePerHop = nativeTransferGasLimit * gasPrice;
+    const hopWalletsInfo = generateWallets(hopCount);
+    const hopWallets = hopWalletsInfo.map((w) => new Wallet(w.privateKey, provider));
+    const hopAmounts = [];
+    for (let i = hopCount - 1; i >= 0; i--) {
+        if (i === hopCount - 1) {
+            hopAmounts.unshift(profitAmount + gasFeePerHop);
+        }
+        else {
+            hopAmounts.unshift(hopAmounts[0] + gasFeePerHop);
+        }
+    }
+    const payerTx = await payerWallet.signTransaction({
+        to: hopWallets[0].address,
+        value: hopAmounts[0],
+        nonce: payerNonce,
+        gasLimit: nativeTransferGasLimit,
+        chainId,
+        ...gasFields,
+    });
+    signedTxs.push(payerTx);
+    for (let i = 0; i < hopCount; i++) {
+        const fromWallet = hopWallets[i];
+        const isLastHop = i === hopCount - 1;
+        const toAddress = isLastHop ? profitRecipient : hopWallets[i + 1].address;
+        const value = isLastHop ? profitAmount : hopAmounts[i + 1];
+        const hopTx = await fromWallet.signTransaction({
+            to: toAddress,
+            value,
+            nonce: 0,
+            gasLimit: nativeTransferGasLimit,
+            chainId,
+            ...gasFields,
+        });
+        signedTxs.push(hopTx);
+    }
+    return {
+        signedTransactions: signedTxs,
+        hopWallets: hopWalletsInfo,
+        totalNonceUsed: 1,
+    };
+}

package/dist/core/index.d.ts

@@ -0,0 +1,5 @@
+/** core public facade */
+export * from './foundation.js';
+export * from './constants/index.js';
+export * from './clients/index.js';
+export * from './erc20.js';

package/dist/core/index.js

@@ -0,0 +1,5 @@
+/** core public facade */
+export * from './foundation.js';
+export * from './constants/index.js';
+export * from './clients/index.js';
+export * from './erc20.js';

package/dist/core/legacy-types/errors.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 统一 SDK 错误代码
+ *
+ * 合并 Four.meme (parseFourError) 和 Flap Protocol (parseFlapError) 的错误代码。
+ */
+export declare enum SdkErrorCode {
+    UNKNOWN_ERROR = "UNKNOWN_ERROR",
+    INSUFFICIENT_BALANCE = "INSUFFICIENT_BALANCE",
+    SLIPPAGE_EXCEEDED = "SLIPPAGE_EXCEEDED",
+    TRANSACTION_FAILED = "TRANSACTION_FAILED",
+    TOKEN_ALREADY_EXISTS = "TOKEN_ALREADY_EXISTS",
+    TOKEN_NOT_FOUND = "TOKEN_NOT_FOUND",
+    TOKEN_NOT_TRADABLE = "TOKEN_NOT_TRADABLE",
+    ALREADY_ON_DEX = "ALREADY_ON_DEX",
+    FOUR_GWEI_PRECISION = "FOUR_GWEI_PRECISION",
+    FOUR_ZERO_ADDRESS = "FOUR_ZERO_ADDRESS",
+    FOUR_SLIPPAGE = "FOUR_SLIPPAGE",
+    FOUR_INSUFFICIENT_FUNDS = "FOUR_INSUFFICIENT_FUNDS",
+    FOUR_FEE_TOO_HIGH = "FOUR_FEE_TOO_HIGH",
+    FOUR_ORDER_TOO_SMALL = "FOUR_ORDER_TOO_SMALL",
+    INVALID_AMOUNT = "INVALID_AMOUNT",
+    INVALID_TOKEN = "INVALID_TOKEN",
+    INVALID_QUOTE_TOKEN = "INVALID_QUOTE_TOKEN",
+    TAX_RATE_TOO_HIGH = "TAX_RATE_TOO_HIGH",
+    PERMIT_EXPIRED = "PERMIT_EXPIRED",
+    PERMIT_INVALID = "PERMIT_INVALID"
+}

package/dist/core/legacy-types/errors.js

@@ -0,0 +1,34 @@
+/**
+ * 统一 SDK 错误代码
+ *
+ * 合并 Four.meme (parseFourError) 和 Flap Protocol (parseFlapError) 的错误代码。
+ */
+export var SdkErrorCode;
+(function (SdkErrorCode) {
+    // Generic
+    SdkErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+    // Transaction / Bundle
+    SdkErrorCode["INSUFFICIENT_BALANCE"] = "INSUFFICIENT_BALANCE";
+    SdkErrorCode["SLIPPAGE_EXCEEDED"] = "SLIPPAGE_EXCEEDED";
+    SdkErrorCode["TRANSACTION_FAILED"] = "TRANSACTION_FAILED";
+    // Token state
+    SdkErrorCode["TOKEN_ALREADY_EXISTS"] = "TOKEN_ALREADY_EXISTS";
+    SdkErrorCode["TOKEN_NOT_FOUND"] = "TOKEN_NOT_FOUND";
+    SdkErrorCode["TOKEN_NOT_TRADABLE"] = "TOKEN_NOT_TRADABLE";
+    SdkErrorCode["ALREADY_ON_DEX"] = "ALREADY_ON_DEX";
+    // Four.meme specific
+    SdkErrorCode["FOUR_GWEI_PRECISION"] = "FOUR_GWEI_PRECISION";
+    SdkErrorCode["FOUR_ZERO_ADDRESS"] = "FOUR_ZERO_ADDRESS";
+    SdkErrorCode["FOUR_SLIPPAGE"] = "FOUR_SLIPPAGE";
+    SdkErrorCode["FOUR_INSUFFICIENT_FUNDS"] = "FOUR_INSUFFICIENT_FUNDS";
+    SdkErrorCode["FOUR_FEE_TOO_HIGH"] = "FOUR_FEE_TOO_HIGH";
+    SdkErrorCode["FOUR_ORDER_TOO_SMALL"] = "FOUR_ORDER_TOO_SMALL";
+    // Validation
+    SdkErrorCode["INVALID_AMOUNT"] = "INVALID_AMOUNT";
+    SdkErrorCode["INVALID_TOKEN"] = "INVALID_TOKEN";
+    SdkErrorCode["INVALID_QUOTE_TOKEN"] = "INVALID_QUOTE_TOKEN";
+    SdkErrorCode["TAX_RATE_TOO_HIGH"] = "TAX_RATE_TOO_HIGH";
+    // Permit
+    SdkErrorCode["PERMIT_EXPIRED"] = "PERMIT_EXPIRED";
+    SdkErrorCode["PERMIT_INVALID"] = "PERMIT_INVALID";
+})(SdkErrorCode || (SdkErrorCode = {}));

package/dist/core/nonce/nonce-manager.d.ts

@@ -0,0 +1,19 @@
+import '../tx/wallet-sign-patch.js';
+import { JsonRpcProvider, Wallet } from 'ethers';
+/**
+ * Nonce 管理器 — bundle 交易中管理多钱包 nonce
+ */
+export declare class NonceManager {
+    private provider;
+    private tempNonceCache;
+    private chainIdPromise?;
+    private addressNonceTail;
+    constructor(provider: JsonRpcProvider);
+    private withAddressLock;
+    private getChainId;
+    getNextNonce(wallet: Wallet | string): Promise<number>;
+    getNextNonceBatch(wallet: Wallet | string, count: number): Promise<number[]>;
+    clearTemp(): void;
+    getTempCachedNonce(address: string): number | undefined;
+    getNextNoncesForWallets(wallets: (Wallet | string)[]): Promise<number[]>;
+}

package/dist/core/nonce/nonce-manager.js

@@ -0,0 +1,217 @@
+import '../tx/wallet-sign-patch.js';
+import { CHAINS } from '../constants/index.js';
+function asBatchSendProvider(provider) {
+    return provider;
+}
+const GLOBAL_NONCE_TTL_MS = 60 * 1000;
+const globalNonceCursorByChain = new Map();
+function isFlakyNonceChain(chainId) {
+    return Number(chainId) === CHAINS.XLAYER.chainId;
+}
+function getCursorMap(chainId) {
+    let m = globalNonceCursorByChain.get(chainId);
+    if (!m) {
+        m = new Map();
+        globalNonceCursorByChain.set(chainId, m);
+    }
+    return m;
+}
+function getGlobalNextNonce(chainId, addrLower) {
+    const m = globalNonceCursorByChain.get(chainId);
+    if (!m)
+        return undefined;
+    const e = m.get(addrLower);
+    if (!e)
+        return undefined;
+    if (Date.now() - e.updatedAt > GLOBAL_NONCE_TTL_MS) {
+        m.delete(addrLower);
+        return undefined;
+    }
+    return e.nextNonce;
+}
+function setGlobalNextNonce(chainId, addrLower, nextNonce) {
+    const m = getCursorMap(chainId);
+    const cur = m.get(addrLower);
+    const next = Number(nextNonce);
+    if (!Number.isFinite(next) || next < 0)
+        return;
+    if (!cur || next > cur.nextNonce || Date.now() - cur.updatedAt > GLOBAL_NONCE_TTL_MS) {
+        m.set(addrLower, { nextNonce: next, updatedAt: Date.now() });
+    }
+    else {
+        cur.updatedAt = Date.now();
+    }
+}
+/**
+ * Nonce 管理器 — bundle 交易中管理多钱包 nonce
+ */
+export class NonceManager {
+    provider;
+    tempNonceCache = new Map();
+    chainIdPromise;
+    addressNonceTail = new Map();
+    constructor(provider) {
+        this.provider = provider;
+    }
+    async withAddressLock(key, fn) {
+        const prev = this.addressNonceTail.get(key) ?? Promise.resolve();
+        let release;
+        const gate = new Promise((r) => {
+            release = r;
+        });
+        this.addressNonceTail.set(key, prev.then(() => gate));
+        await prev;
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
+    }
+    async getChainId() {
+        if (!this.chainIdPromise) {
+            this.chainIdPromise = this.provider
+                .getNetwork()
+                .then((n) => Number(n.chainId))
+                .catch(() => 0);
+        }
+        return this.chainIdPromise;
+    }
+    async getNextNonce(wallet) {
+        const address = typeof wallet === 'string' ? wallet : wallet.address;
+        const key = address.toLowerCase();
+        return this.withAddressLock(key, async () => {
+            const chainId = await this.getChainId();
+            const flaky = isFlakyNonceChain(chainId);
+            const cachedNonce = this.tempNonceCache.get(key);
+            if (cachedNonce !== undefined) {
+                this.tempNonceCache.set(key, cachedNonce + 1);
+                if (flaky)
+                    setGlobalNextNonce(chainId, key, cachedNonce + 1);
+                return cachedNonce;
+            }
+            const onchainNonce = await this.provider.getTransactionCount(address, 'pending');
+            let effectiveNonce = onchainNonce;
+            if (flaky) {
+                const globalNext = getGlobalNextNonce(chainId, key);
+                if (globalNext !== undefined) {
+                    const delta = globalNext - onchainNonce;
+                    if (delta > 0 && delta <= 10) {
+                        effectiveNonce = globalNext;
+                    }
+                }
+                setGlobalNextNonce(chainId, key, effectiveNonce + 1);
+            }
+            this.tempNonceCache.set(key, effectiveNonce + 1);
+            return effectiveNonce;
+        });
+    }
+    async getNextNonceBatch(wallet, count) {
+        const address = typeof wallet === 'string' ? wallet : wallet.address;
+        const key = address.toLowerCase();
+        return this.withAddressLock(key, async () => {
+            const chainId = await this.getChainId();
+            const flaky = isFlakyNonceChain(chainId);
+            let startNonce;
+            const cachedNonce = this.tempNonceCache.get(key);
+            if (cachedNonce !== undefined) {
+                startNonce = cachedNonce;
+            }
+            else {
+                startNonce = await this.provider.getTransactionCount(address, 'pending');
+            }
+            if (flaky) {
+                const globalNext = getGlobalNextNonce(chainId, key);
+                if (globalNext !== undefined) {
+                    const delta = globalNext - startNonce;
+                    if (delta > 0 && delta <= 10)
+                        startNonce = globalNext;
+                }
+            }
+            this.tempNonceCache.set(key, startNonce + count);
+            if (flaky)
+                setGlobalNextNonce(chainId, key, startNonce + count);
+            return Array.from({ length: count }, (_, i) => startNonce + i);
+        });
+    }
+    clearTemp() {
+        this.tempNonceCache.clear();
+    }
+    getTempCachedNonce(address) {
+        return this.tempNonceCache.get(address.toLowerCase());
+    }
+    async getNextNoncesForWallets(wallets) {
+        const addresses = wallets.map((w) => (typeof w === 'string' ? w : w.address));
+        const keys = addresses.map((a) => a.toLowerCase());
+        const chainId = await this.getChainId();
+        const flaky = isFlakyNonceChain(chainId);
+        const needQueryByKey = new Map();
+        const results = new Array(wallets.length);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const cachedNonce = this.tempNonceCache.get(key);
+            if (cachedNonce !== undefined) {
+                results[i] = cachedNonce;
+                this.tempNonceCache.set(key, cachedNonce + 1);
+                if (flaky)
+                    setGlobalNextNonce(chainId, key, cachedNonce + 1);
+            }
+            else {
+                const pending = needQueryByKey.get(key);
+                if (pending) {
+                    pending.push({ index: i, address: addresses[i] });
+                }
+                else {
+                    needQueryByKey.set(key, [{ index: i, address: addresses[i] }]);
+                }
+            }
+        }
+        if (needQueryByKey.size > 0) {
+            let queryResults;
+            const uniqueQueries = Array.from(needQueryByKey.values()).map((entries) => entries[0]);
+            try {
+                const batchRequests = uniqueQueries.map(({ address }, idx) => ({
+                    method: 'eth_getTransactionCount',
+                    params: [address, 'pending'],
+                    id: idx + 1,
+                    jsonrpc: '2.0',
+                }));
+                const rawResults = await asBatchSendProvider(this.provider)._send(batchRequests);
+                queryResults = rawResults.map((r) => {
+                    if (r.result) {
+                        return parseInt(r.result, 16);
+                    }
+                    return 0;
+                });
+            }
+            catch {
+                const queryPromises = uniqueQueries.map(({ address }) => this.provider.getTransactionCount(address, 'pending'));
+                queryResults = await Promise.all(queryPromises);
+            }
+            for (let i = 0; i < uniqueQueries.length; i++) {
+                const { address } = uniqueQueries[i];
+                const key = address.toLowerCase();
+                const onchainNonce = queryResults[i] ?? 0;
+                let startNonce = onchainNonce;
+                if (flaky) {
+                    const globalNext = getGlobalNextNonce(chainId, key);
+                    if (globalNext !== undefined) {
+                        const delta = globalNext - onchainNonce;
+                        if (delta > 0 && delta <= 10)
+                            startNonce = globalNext;
+                    }
+                }
+                const assignments = needQueryByKey.get(key) ?? [];
+                for (let j = 0; j < assignments.length; j++) {
+                    results[assignments[j].index] = startNonce + j;
+                }
+                const nextNonce = startNonce + assignments.length;
+                this.tempNonceCache.set(key, nextNonce);
+                if (flaky) {
+                    setGlobalNextNonce(chainId, key, nextNonce);
+                }
+            }
+        }
+        return results;
+    }
+}

package/dist/core/normalize-unknown.d.ts

@@ -0,0 +1,9 @@
+/**
+ * SDK 统一的 unknown / Error 收口（审计：catch 宜用 unknown + normalize）
+ */
+export interface NormalizedErrorShape {
+    message: string;
+    cause?: unknown;
+}
+export declare function getErrorMessageFromUnknown(error: unknown): string;
+export declare function normalizeUnknownError(error: unknown): NormalizedErrorShape;

package/dist/core/normalize-unknown.js

@@ -0,0 +1,29 @@
+/**
+ * SDK 统一的 unknown / Error 收口（审计：catch 宜用 unknown + normalize）
+ */
+export function getErrorMessageFromUnknown(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    if (error !== null && typeof error === 'object') {
+        const o = error;
+        const m = o.message;
+        if (typeof m === 'string')
+            return m;
+        const reason = o.reason;
+        if (typeof reason === 'string')
+            return reason;
+    }
+    try {
+        return String(error);
+    }
+    catch {
+        return 'Unknown error';
+    }
+}
+export function normalizeUnknownError(error) {
+    const message = getErrorMessageFromUnknown(error);
+    const cause = error instanceof Error && error.cause !== undefined ? error.cause : error instanceof Error ? undefined : error;
+    return { message, ...(cause !== undefined ? { cause } : {}) };
+}

package/dist/core/sdk-logger.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SDK 可选日志门面（默认静默）；业务侧可传入以替代 console.*
+ */
+export interface SdkLogger {
+    debug?: (msg: string, ...args: unknown[]) => void;
+    info?: (msg: string, ...args: unknown[]) => void;
+    warn?: (msg: string, ...args: unknown[]) => void;
+    error?: (msg: string, ...args: unknown[]) => void;
+}
+/** 不输出日志（库的推荐默认）。 */
+export declare const noopSdkLogger: SdkLogger;
+/** 直接使用 console（仅调试/过渡期）。 */
+export declare const consoleSdkLogger: SdkLogger;

package/dist/core/sdk-logger.js

@@ -0,0 +1,12 @@
+/**
+ * SDK 可选日志门面（默认静默）；业务侧可传入以替代 console.*
+ */
+/** 不输出日志（库的推荐默认）。 */
+export const noopSdkLogger = {};
+/** 直接使用 console（仅调试/过渡期）。 */
+export const consoleSdkLogger = {
+    debug: (msg, ...args) => console.debug(msg, ...args),
+    info: (msg, ...args) => console.info(msg, ...args),
+    warn: (msg, ...args) => console.warn(msg, ...args),
+    error: (msg, ...args) => console.error(msg, ...args),
+};

package/dist/core/shared-abis/common.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @deprecated 兼容路径 — 唯一数据源见 `src/abis/common.ts`
+ */
+export * from '../../abis/common.js';

package/dist/core/shared-abis/common.js

@@ -0,0 +1,4 @@
+/**
+ * @deprecated 兼容路径 — 唯一数据源见 `src/abis/common.ts`
+ */
+export * from '../../abis/common.js';

package/dist/core/shared-abis/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * ABI 导出（兼容路径：历史代码多从此处 import）。
+ * 唯一数据源见 `src/abis/`。
+ */
+export * from '../../abis/index.js';

package/dist/core/shared-abis/index.js

@@ -0,0 +1,5 @@
+/**
+ * ABI 导出（兼容路径：历史代码多从此处 import）。
+ * 唯一数据源见 `src/abis/`。
+ */
+export * from '../../abis/index.js';

package/dist/core/tx/build-request.d.ts

@@ -0,0 +1,17 @@
+import type { TransactionLike, TransactionRequest } from 'ethers';
+/** 构建签名用 TransactionRequest 的公共参数 */
+export type BuildTxRequestParams = {
+    from: string;
+    nonce: number;
+    gasLimit: bigint;
+    gasPrice: bigint;
+    priorityFee: bigint;
+    chainId: number;
+    txType: number;
+    value?: bigint;
+};
+/**
+ * 将 populateTransaction 结果与 gas/nonce 字段合并为可签名交易。
+ * type 0 (Legacy) 使用 gasPrice；type 2 (EIP-1559) 使用 maxFeePerGas + maxPriorityFeePerGas。
+ */
+export declare function buildTransactionRequest(unsigned: TransactionLike, { from, nonce, gasLimit, gasPrice, priorityFee, chainId, txType, value }: BuildTxRequestParams): TransactionRequest;

package/dist/core/tx/build-request.js

@@ -0,0 +1,25 @@
+/**
+ * 将 populateTransaction 结果与 gas/nonce 字段合并为可签名交易。
+ * type 0 (Legacy) 使用 gasPrice；type 2 (EIP-1559) 使用 maxFeePerGas + maxPriorityFeePerGas。
+ */
+export function buildTransactionRequest(unsigned, { from, nonce, gasLimit, gasPrice, priorityFee, chainId, txType, value }) {
+    const tx = {
+        ...unsigned,
+        from,
+        nonce,
+        gasLimit,
+        chainId,
+        type: txType,
+    };
+    if (value !== undefined) {
+        tx.value = value;
+    }
+    if (txType === 2) {
+        tx.maxFeePerGas = gasPrice;
+        tx.maxPriorityFeePerGas = priorityFee;
+    }
+    else {
+        tx.gasPrice = gasPrice;
+    }
+    return tx;
+}

package/dist/core/tx/sign-batch.d.ts

@@ -0,0 +1,5 @@
+import { JsonRpcProvider, Wallet, type TransactionRequest } from 'ethers';
+export declare function getChainId(provider: JsonRpcProvider, configChainId?: number): Promise<number>;
+export declare function signTransactionsBatch(wallet: Wallet, transactions: TransactionRequest[]): Promise<string[]>;
+export declare function signTransactionsBatchMultiWallet(wallets: Wallet[], transactions: TransactionRequest[]): Promise<string[]>;
+export declare function validateSignedTransactions(signedTxs: string[]): boolean;

package/dist/core/tx/sign-batch.js

@@ -0,0 +1,26 @@
+export async function getChainId(provider, configChainId) {
+    if (configChainId !== undefined)
+        return configChainId;
+    const network = await provider.getNetwork();
+    return Number(network.chainId);
+}
+export async function signTransactionsBatch(wallet, transactions) {
+    return Promise.all(transactions.map((tx) => wallet.signTransaction(tx)));
+}
+export async function signTransactionsBatchMultiWallet(wallets, transactions) {
+    if (wallets.length !== transactions.length) {
+        throw new Error(`Wallet count (${wallets.length}) must match transaction count (${transactions.length})`);
+    }
+    return Promise.all(transactions.map((tx, i) => wallets[i].signTransaction(tx)));
+}
+export function validateSignedTransactions(signedTxs) {
+    if (!signedTxs || signedTxs.length === 0) {
+        return false;
+    }
+    for (const tx of signedTxs) {
+        if (typeof tx !== 'string' || !tx.startsWith('0x')) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/core/tx/wallet-sign-patch.d.ts

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

package/dist/core/tx/wallet-sign-patch.js

@@ -0,0 +1,18 @@
+/**
+ * EIP-1559 兼容：当 txType=2 但传了 gasPrice 时，自动转换为 maxFeePerGas
+ * 模块加载时 patch Wallet.prototype.signTransaction（全局一次）
+ */
+import { Wallet } from 'ethers';
+const _origWalletSign = Wallet.prototype.signTransaction;
+Wallet.prototype.signTransaction = async function (tx) {
+    const signable = tx;
+    if (signable.type === 2 && signable.gasPrice != null && signable.maxFeePerGas == null) {
+        const { gasPrice: gp, ...rest } = signable;
+        return _origWalletSign.call(this, {
+            ...rest,
+            maxFeePerGas: gp,
+            maxPriorityFeePerGas: rest.maxPriorityFeePerGas ?? 0n,
+        });
+    }
+    return _origWalletSign.call(this, tx);
+};

package/dist/core/types/airdrop-sweep.d.ts

@@ -0,0 +1,79 @@
+/**
+ * 空投分散 / 归集（airdrop-sweep）— 类型定义
+ */
+import type { SoulPointSignatureMode, VNormalizationMode } from '../clients/club48.js';
+export type BundleSubmitResult = {
+    bundleUuid: string;
+    signedTxs: string[];
+};
+export type SignedTransactionsResult = {
+    signedTransactions: string[];
+};
+export type AirdropDisperseParams = {
+    rpcUrl: string;
+    chainId: number;
+    fromPrivateKey: string;
+    recipients: string[];
+    amount?: string;
+    amounts?: string[];
+    tokenAddress?: string;
+    bundleEndpoint?: string;
+    gasPriceGwei?: string;
+    transferGasLimit?: bigint;
+    nativeGasLimit?: bigint;
+    blockOffset?: number;
+    spMode?: SoulPointSignatureMode;
+    spPrivateKey?: string;
+    spVMode?: VNormalizationMode;
+};
+export type AirdropDisperseSignParams = {
+    rpcUrl: string;
+    chainId: number;
+    fromPrivateKey: string;
+    recipients: string[];
+    amount?: string;
+    amounts?: string[];
+    tokenAddress?: string;
+    gasPriceGwei?: string;
+    transferGasLimit?: bigint;
+    nativeGasLimit?: bigint;
+};
+export type AirdropSweepParams = {
+    rpcUrl: string;
+    chainId: number;
+    sourcePrivateKeys: string[];
+    target: string;
+    ratioPct?: number;
+    amount?: string;
+    tokenAddress?: string;
+    bundleEndpoint?: string;
+    gasPriceGwei?: string;
+    transferGasLimit?: bigint;
+    nativeGasLimit?: bigint;
+    blockOffset?: number;
+    skipIfInsufficient?: boolean;
+    spMode?: SoulPointSignatureMode;
+    spPrivateKey?: string;
+    spVMode?: VNormalizationMode;
+};
+export type AirdropSweepSignParams = {
+    rpcUrl: string;
+    chainId: number;
+    sourcePrivateKeys: string[];
+    target: string;
+    ratioPct?: number;
+    amount?: string;
+    tokenAddress?: string;
+    gasPriceGwei?: string;
+    transferGasLimit?: bigint;
+    nativeGasLimit?: bigint;
+    skipIfInsufficient?: boolean;
+};
+/** @deprecated 使用 `AirdropDisperseParams` */
+export type DisperseParams = AirdropDisperseParams;
+/** @deprecated 使用 `AirdropDisperseSignParams` */
+export type DisperseSignParams = AirdropDisperseSignParams;
+/** @deprecated 使用 `AirdropSweepParams` */
+export type SweepParams = AirdropSweepParams;
+/** @deprecated 使用 `AirdropSweepSignParams` */
+export type SweepSignParams = AirdropSweepSignParams;

package/dist/core/types/airdrop-sweep.js

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