four-flap-meme-sdk 1.9.49 → 2.1.0

package/dist/shared/foundation/gas/bundle-gas.d.ts

@@ -0,0 +1,39 @@
+import { JsonRpcProvider, type TransactionRequest } from 'ethers';
+export interface GasPriceConfig {
+    baseGasPrice?: bigint;
+    multiplierPercent?: number;
+    minGasPrice?: bigint;
+    maxGasPrice?: bigint;
+}
+export declare function getOptimizedGasPrice(provider: JsonRpcProvider, config?: GasPriceConfig): Promise<bigint>;
+export interface GasEstimateConfig {
+    multiplier?: number;
+    fallbackGasLimit?: bigint;
+    allowFailure?: boolean;
+}
+export declare function estimateGasWithSafety(provider: JsonRpcProvider, txRequest: TransactionRequest, config?: GasEstimateConfig): Promise<bigint>;
+export declare function estimateGasBatch(provider: JsonRpcProvider, txRequests: TransactionRequest[], config?: GasEstimateConfig): Promise<bigint[]>;
+export interface BuildTransactionOptions {
+    from: string;
+    to?: string;
+    data?: string;
+    value?: bigint;
+    nonce: number;
+    gasPrice: bigint;
+    gasLimit: bigint;
+    chainId: number;
+    type?: 0 | 2;
+}
+export declare function buildTransaction(options: BuildTransactionOptions): TransactionRequest;
+export interface CommonBundleConfig {
+    gasLimit?: number;
+    gasLimitMultiplier?: number;
+    minGasPriceGwei?: number;
+    maxGasPriceGwei?: number;
+    txType?: 0 | 2;
+    chainId?: number;
+}
+export declare function getGasLimit(config: CommonBundleConfig, defaultGas?: number): bigint;
+export declare function getGasPriceConfig(config: CommonBundleConfig): GasPriceConfig;
+export declare function getTxType(config: CommonBundleConfig): 0 | 2;
+export declare function buildGasFields(txType: number, gasPrice: bigint): Record<string, unknown>;

package/dist/shared/foundation/gas/bundle-gas.js

@@ -0,0 +1,93 @@
+import { ethers } from 'ethers';
+export async function getOptimizedGasPrice(provider, config) {
+    const feeData = await provider.getFeeData();
+    const chainGasPrice = feeData.gasPrice || ethers.parseUnits('3', 'gwei');
+    let gasPrice;
+    if (config?.baseGasPrice) {
+        gasPrice = config.baseGasPrice;
+    }
+    else {
+        gasPrice = chainGasPrice;
+    }
+    const multiplier = config?.multiplierPercent ?? 50;
+    gasPrice = (gasPrice * BigInt(100 + multiplier)) / 100n;
+    if (gasPrice < chainGasPrice) {
+        gasPrice = chainGasPrice;
+    }
+    if (config?.minGasPrice && gasPrice < config.minGasPrice) {
+        gasPrice = config.minGasPrice;
+    }
+    if (config?.maxGasPrice && gasPrice > config.maxGasPrice) {
+        gasPrice = config.maxGasPrice;
+    }
+    return gasPrice;
+}
+export async function estimateGasWithSafety(provider, txRequest, config) {
+    const multiplier = config?.multiplier ?? 1.2;
+    const fallback = config?.fallbackGasLimit ?? 600000n;
+    const allowFailure = config?.allowFailure ?? true;
+    try {
+        const estimated = await provider.estimateGas(txRequest);
+        return BigInt(Math.ceil(Number(estimated) * multiplier));
+    }
+    catch (error) {
+        if (!allowFailure) {
+            throw error;
+        }
+        return fallback;
+    }
+}
+export async function estimateGasBatch(provider, txRequests, config) {
+    return Promise.all(txRequests.map((req) => estimateGasWithSafety(provider, req, config)));
+}
+export function buildTransaction(options) {
+    const tx = {
+        from: options.from,
+        nonce: options.nonce,
+        gasLimit: options.gasLimit,
+        chainId: options.chainId,
+    };
+    if (options.to)
+        tx.to = options.to;
+    if (options.data)
+        tx.data = options.data;
+    if (options.value)
+        tx.value = options.value;
+    if (options.type === 2) {
+        tx.type = 2;
+        tx.maxFeePerGas = options.gasPrice;
+        tx.maxPriorityFeePerGas = options.gasPrice / 10n;
+    }
+    else {
+        tx.type = 0;
+        tx.gasPrice = options.gasPrice;
+    }
+    return tx;
+}
+export function getGasLimit(config, defaultGas = 500000) {
+    if (config.gasLimit !== undefined) {
+        return typeof config.gasLimit === 'bigint' ? config.gasLimit : BigInt(config.gasLimit);
+    }
+    const multiplier = config.gasLimitMultiplier ?? 1.0;
+    return BigInt(Math.ceil(defaultGas * multiplier));
+}
+export function getGasPriceConfig(config) {
+    const gasPriceConfig = {};
+    if (config.minGasPriceGwei !== undefined) {
+        gasPriceConfig.baseGasPrice = ethers.parseUnits(String(config.minGasPriceGwei), 'gwei');
+        gasPriceConfig.multiplierPercent = 0;
+    }
+    if (config.maxGasPriceGwei !== undefined) {
+        gasPriceConfig.maxGasPrice = ethers.parseUnits(String(config.maxGasPriceGwei), 'gwei');
+    }
+    return gasPriceConfig;
+}
+export function getTxType(config) {
+    return config.txType ?? 0;
+}
+export function buildGasFields(txType, gasPrice) {
+    if (txType === 2) {
+        return { type: 2, maxFeePerGas: gasPrice, maxPriorityFeePerGas: gasPrice / 10n || 1n };
+    }
+    return { type: 0, gasPrice };
+}

package/dist/shared/foundation/gas/profit-hop.d.ts

@@ -0,0 +1,20 @@
+import { JsonRpcProvider, Wallet } from 'ethers';
+import { type GeneratedWallet } from '../../../utils/wallet.js';
+export interface ProfitHopConfig {
+    provider: JsonRpcProvider;
+    payerWallet: Wallet;
+    profitAmount: bigint;
+    profitRecipient: string;
+    hopCount?: number;
+    gasPrice: bigint;
+    chainId: number;
+    txType: number;
+    startNonce?: number;
+}
+export interface ProfitHopResult {
+    signedTransactions: string[];
+    hopWallets: GeneratedWallet[];
+    totalNonceUsed: number;
+}
+export declare const PROFIT_HOP_COUNT = 2;
+export declare function buildProfitHopTransactions(config: ProfitHopConfig): Promise<ProfitHopResult>;

package/dist/shared/foundation/gas/profit-hop.js

@@ -0,0 +1,72 @@
+import { Wallet } from 'ethers';
+import { generateWallets } from '../../../utils/wallet.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/shared/foundation/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SDK 横向基础（错误规范化、可选日志、共享类型与 Tx 构建）。
+ * 新代码优先从这里收口 unknown / Logger / 复用类型；存量代码可渐进迁移。
+ */
+export { getErrorMessageFromUnknown, normalizeUnknownError, type NormalizedErrorShape } from './normalize-unknown.js';
+export { noopSdkLogger, consoleSdkLogger, type SdkLogger } from './sdk-logger.js';
+export type { Aggregate3CallResult, EnsureAllowanceResult, EnsureAllowanceBatchItemResult, ApproveTokenBatchParams, ApproveTokenBatchRawParams, ApproveTokenBatchResult, ApproveTokenBatchSignResult, HoldersMakerChain, HoldersMakerTradeType, BaseTokenType, HoldersMakerConfig, HoldersMakerParams, TransactionLayer, BatchResult, HoldersMakerResult, DexConfig, ChainDexConfig, PoolPairInfo, V3PoolInfo, DexPoolInfo, BestPoolInfo, LPPlatform, LPInfo, InspectOptions, BundleSubmitResult, SignedTransactionsResult, AirdropDisperseParams, AirdropDisperseSignParams, AirdropSweepParams, AirdropSweepSignParams, DisperseParams, DisperseSignParams, SweepParams, SweepSignParams, PrivateSaleSignConfig, PrivateSaleTransferParams, BatchPrivateSaleParams, PrivateSaleResult, SupportedChain, QuoteParams, QuoteResult, } from './types/index.js';
+export { buildTransactionRequest, type BuildTxRequestParams } from './tx/build-request.js';
+export { NonceManager } from './nonce/nonce-manager.js';
+export { type GasPriceConfig, type GasEstimateConfig, type BuildTransactionOptions, type CommonBundleConfig, getOptimizedGasPrice, estimateGasWithSafety, estimateGasBatch, buildTransaction, getGasLimit, getGasPriceConfig, getTxType, buildGasFields, } from './gas/bundle-gas.js';
+export { type ProfitHopConfig, type ProfitHopResult, PROFIT_HOP_COUNT, buildProfitHopTransactions, } from './gas/profit-hop.js';
+export { getChainId, signTransactionsBatch, signTransactionsBatchMultiWallet, validateSignedTransactions, } from './tx/sign-batch.js';
+export { getDeadline, encodeV3Path, decodeV3Path } from './dex/v3-path.js';

package/dist/shared/foundation/index.js

@@ -0,0 +1,12 @@
+/**
+ * SDK 横向基础（错误规范化、可选日志、共享类型与 Tx 构建）。
+ * 新代码优先从这里收口 unknown / Logger / 复用类型；存量代码可渐进迁移。
+ */
+export { getErrorMessageFromUnknown, normalizeUnknownError } from './normalize-unknown.js';
+export { noopSdkLogger, consoleSdkLogger } from './sdk-logger.js';
+export { buildTransactionRequest } from './tx/build-request.js';
+export { NonceManager } from './nonce/nonce-manager.js';
+export { getOptimizedGasPrice, estimateGasWithSafety, estimateGasBatch, buildTransaction, getGasLimit, getGasPriceConfig, getTxType, buildGasFields, } from './gas/bundle-gas.js';
+export { PROFIT_HOP_COUNT, buildProfitHopTransactions, } from './gas/profit-hop.js';
+export { getChainId, signTransactionsBatch, signTransactionsBatchMultiWallet, validateSignedTransactions, } from './tx/sign-batch.js';
+export { getDeadline, encodeV3Path, decodeV3Path } from './dex/v3-path.js';

package/dist/shared/foundation/nonce/nonce-manager.d.ts

@@ -0,0 +1,17 @@
+import '../tx/wallet-sign-patch.js';
+import { JsonRpcProvider, Wallet } from 'ethers';
+/**
+ * Nonce 管理器 — bundle 交易中管理多钱包 nonce
+ */
+export declare class NonceManager {
+    private provider;
+    private tempNonceCache;
+    private chainIdPromise?;
+    constructor(provider: JsonRpcProvider);
+    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/shared/foundation/nonce/nonce-manager.js

@@ -0,0 +1,180 @@
+import '../tx/wallet-sign-patch.js';
+import { CHAINS } from '../../constants/index.js';
+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;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    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();
+        const chainId = await this.getChainId();
+        const flaky = isFlakyNonceChain(chainId);
+        if (this.tempNonceCache.has(key)) {
+            const cachedNonce = this.tempNonceCache.get(key);
+            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();
+        const chainId = await this.getChainId();
+        const flaky = isFlakyNonceChain(chainId);
+        let startNonce;
+        if (this.tempNonceCache.has(key)) {
+            startNonce = this.tempNonceCache.get(key);
+        }
+        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 needQuery = [];
+        const results = new Array(wallets.length);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (this.tempNonceCache.has(key)) {
+                const cachedNonce = this.tempNonceCache.get(key);
+                results[i] = cachedNonce;
+                this.tempNonceCache.set(key, cachedNonce + 1);
+                if (flaky)
+                    setGlobalNextNonce(chainId, key, cachedNonce + 1);
+            }
+            else {
+                needQuery.push({ index: i, address: addresses[i] });
+            }
+        }
+        if (needQuery.length > 0) {
+            let queryResults;
+            try {
+                const batchRequests = needQuery.map(({ address }, idx) => ({
+                    method: 'eth_getTransactionCount',
+                    params: [address, 'pending'],
+                    id: idx + 1,
+                    jsonrpc: '2.0',
+                }));
+                const rawResults = await this.provider._send(batchRequests);
+                queryResults = rawResults.map((r) => {
+                    if (r.result) {
+                        return parseInt(r.result, 16);
+                    }
+                    return 0;
+                });
+            }
+            catch {
+                const queryPromises = needQuery.map(({ address }) => this.provider.getTransactionCount(address, 'pending'));
+                queryResults = await Promise.all(queryPromises);
+            }
+            for (let i = 0; i < needQuery.length; i++) {
+                const { index, address } = needQuery[i];
+                const key = address.toLowerCase();
+                const onchainNonce = queryResults[i];
+                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);
+                }
+                results[index] = effectiveNonce;
+                this.tempNonceCache.set(key, effectiveNonce + 1);
+            }
+        }
+        return results;
+    }
+}

package/dist/shared/foundation/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/shared/foundation/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/shared/foundation/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/shared/foundation/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/shared/foundation/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/shared/foundation/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/shared/foundation/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/shared/foundation/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/shared/foundation/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);
+};