@t402/smart-router 1.0.0-beta.1

package/dist/chunk-QIZPPHGB.js

@@ -0,0 +1,169 @@
+// src/routing/types.ts
+import { z } from "zod";
+var ChainId = z.string().regex(/^[a-z0-9]+:[a-zA-Z0-9]+$/);
+var AssetId = z.string();
+var OptimizationStrategy = z.enum([
+  "cost",
+  // Minimize total cost (fees + gas)
+  "speed",
+  // Minimize execution time
+  "privacy",
+  // Maximize privacy
+  "balanced",
+  // Balance all factors
+  "slippage"
+  // Minimize slippage
+]);
+var RouteStepType = z.enum([
+  "transfer",
+  // Simple token transfer
+  "swap",
+  // DEX swap
+  "bridge",
+  // Cross-chain bridge
+  "wrap",
+  // Wrap native token
+  "unwrap",
+  // Unwrap to native
+  "approve",
+  // Token approval
+  "deposit",
+  // Deposit to contract
+  "withdraw"
+  // Withdraw from contract
+]);
+var ProtocolId = z.string();
+var RouteRequest = z.object({
+  // Source
+  sourceChain: ChainId,
+  sourceAsset: AssetId,
+  sourceAmount: z.string(),
+  // Amount to send
+  // Destination
+  destinationChain: ChainId,
+  destinationAsset: AssetId.optional(),
+  // If different from source
+  recipient: z.string(),
+  // Options
+  optimization: OptimizationStrategy.default("balanced"),
+  maxSlippage: z.string().default("0.5"),
+  // Percentage
+  maxHops: z.number().int().min(1).max(10).default(5),
+  deadline: z.number().optional(),
+  // Unix timestamp
+  // Preferences
+  preferredProtocols: z.array(ProtocolId).optional(),
+  excludedProtocols: z.array(ProtocolId).optional(),
+  preferredBridges: z.array(ProtocolId).optional(),
+  excludedBridges: z.array(ProtocolId).optional(),
+  // Sender info
+  sender: z.string(),
+  // Feature flags
+  includeMevProtection: z.boolean().default(true),
+  includeGasEstimate: z.boolean().default(true)
+});
+var RouteStep = z.object({
+  id: z.string(),
+  type: RouteStepType,
+  chain: ChainId,
+  protocol: ProtocolId.optional(),
+  // Assets
+  inputAsset: AssetId,
+  outputAsset: AssetId,
+  inputAmount: z.string(),
+  outputAmount: z.string(),
+  // Expected output
+  minOutputAmount: z.string(),
+  // Minimum after slippage
+  // Contract interaction
+  contract: z.string(),
+  calldata: z.string().optional(),
+  value: z.string().optional(),
+  // Native token value
+  // Estimates
+  estimatedGas: z.string(),
+  estimatedTime: z.number(),
+  // Seconds
+  // Fees
+  protocolFee: z.string().optional(),
+  bridgeFee: z.string().optional(),
+  // Metadata
+  priceImpact: z.string().optional(),
+  exchangeRate: z.string().optional(),
+  metadata: z.record(z.unknown()).optional()
+});
+var Route = z.object({
+  id: z.string(),
+  steps: z.array(RouteStep),
+  // Summary
+  sourceChain: ChainId,
+  destinationChain: ChainId,
+  sourceAsset: AssetId,
+  destinationAsset: AssetId,
+  sourceAmount: z.string(),
+  destinationAmount: z.string(),
+  // Expected output
+  minDestinationAmount: z.string(),
+  // After slippage
+  // Costs
+  totalGasCost: z.string(),
+  // In USD
+  totalProtocolFees: z.string(),
+  // In USD
+  totalBridgeFees: z.string(),
+  // In USD
+  totalCost: z.string(),
+  // Total fees in USD
+  // Time
+  estimatedTime: z.number(),
+  // Total seconds
+  // Quality metrics
+  priceImpact: z.string(),
+  // Percentage
+  confidence: z.number().min(0).max(100),
+  // Route reliability score
+  // Metadata
+  optimization: OptimizationStrategy,
+  warnings: z.array(z.string()),
+  createdAt: z.number(),
+  expiresAt: z.number()
+});
+var RouteComparison = z.object({
+  bestRoute: Route,
+  alternatives: z.array(Route),
+  comparison: z.object({
+    costSavings: z.string(),
+    // Best vs worst
+    timeDifference: z.number(),
+    // Seconds
+    riskDifference: z.number()
+    // Confidence difference
+  })
+});
+var RouteValidation = z.object({
+  valid: z.boolean(),
+  errors: z.array(z.object({
+    step: z.number().optional(),
+    code: z.string(),
+    message: z.string()
+  })),
+  warnings: z.array(z.object({
+    step: z.number().optional(),
+    code: z.string(),
+    message: z.string()
+  }))
+});
+
+export {
+  ChainId,
+  AssetId,
+  OptimizationStrategy,
+  RouteStepType,
+  ProtocolId,
+  RouteRequest,
+  RouteStep,
+  Route,
+  RouteComparison,
+  RouteValidation
+};
+//# sourceMappingURL=chunk-QIZPPHGB.js.map

package/dist/chunk-QIZPPHGB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/routing/types.ts"],"sourcesContent":["import { z } from 'zod';\n\n/**\n * Supported chain identifiers (CAIP-2 format)\n */\nexport const ChainId = z.string().regex(/^[a-z0-9]+:[a-zA-Z0-9]+$/);\nexport type ChainId = z.infer<typeof ChainId>;\n\n/**\n * Asset identifier\n */\nexport const AssetId = z.string();\nexport type AssetId = z.infer<typeof AssetId>;\n\n/**\n * Route optimization strategy\n */\nexport const OptimizationStrategy = z.enum([\n  'cost',      // Minimize total cost (fees + gas)\n  'speed',     // Minimize execution time\n  'privacy',   // Maximize privacy\n  'balanced',  // Balance all factors\n  'slippage',  // Minimize slippage\n]);\nexport type OptimizationStrategy = z.infer<typeof OptimizationStrategy>;\n\n/**\n * Route step type\n */\nexport const RouteStepType = z.enum([\n  'transfer',     // Simple token transfer\n  'swap',         // DEX swap\n  'bridge',       // Cross-chain bridge\n  'wrap',         // Wrap native token\n  'unwrap',       // Unwrap to native\n  'approve',      // Token approval\n  'deposit',      // Deposit to contract\n  'withdraw',     // Withdraw from contract\n]);\nexport type RouteStepType = z.infer<typeof RouteStepType>;\n\n/**\n * Protocol identifier\n */\nexport const ProtocolId = z.string();\nexport type ProtocolId = z.infer<typeof ProtocolId>;\n\n/**\n * Route request\n */\nexport const RouteRequest = z.object({\n  // Source\n  sourceChain: ChainId,\n  sourceAsset: AssetId,\n  sourceAmount: z.string(), // Amount to send\n\n  // Destination\n  destinationChain: ChainId,\n  destinationAsset: AssetId.optional(), // If different from source\n  recipient: z.string(),\n\n  // Options\n  optimization: OptimizationStrategy.default('balanced'),\n  maxSlippage: z.string().default('0.5'), // Percentage\n  maxHops: z.number().int().min(1).max(10).default(5),\n  deadline: z.number().optional(), // Unix timestamp\n\n  // Preferences\n  preferredProtocols: z.array(ProtocolId).optional(),\n  excludedProtocols: z.array(ProtocolId).optional(),\n  preferredBridges: z.array(ProtocolId).optional(),\n  excludedBridges: z.array(ProtocolId).optional(),\n\n  // Sender info\n  sender: z.string(),\n\n  // Feature flags\n  includeMevProtection: z.boolean().default(true),\n  includeGasEstimate: z.boolean().default(true),\n});\nexport type RouteRequest = z.infer<typeof RouteRequest>;\n\n/**\n * Individual route step\n */\nexport const RouteStep = z.object({\n  id: z.string(),\n  type: RouteStepType,\n  chain: ChainId,\n  protocol: ProtocolId.optional(),\n\n  // Assets\n  inputAsset: AssetId,\n  outputAsset: AssetId,\n  inputAmount: z.string(),\n  outputAmount: z.string(), // Expected output\n  minOutputAmount: z.string(), // Minimum after slippage\n\n  // Contract interaction\n  contract: z.string(),\n  calldata: z.string().optional(),\n  value: z.string().optional(), // Native token value\n\n  // Estimates\n  estimatedGas: z.string(),\n  estimatedTime: z.number(), // Seconds\n\n  // Fees\n  protocolFee: z.string().optional(),\n  bridgeFee: z.string().optional(),\n\n  // Metadata\n  priceImpact: z.string().optional(),\n  exchangeRate: z.string().optional(),\n  metadata: z.record(z.unknown()).optional(),\n});\nexport type RouteStep = z.infer<typeof RouteStep>;\n\n/**\n * Complete route\n */\nexport const Route = z.object({\n  id: z.string(),\n  steps: z.array(RouteStep),\n\n  // Summary\n  sourceChain: ChainId,\n  destinationChain: ChainId,\n  sourceAsset: AssetId,\n  destinationAsset: AssetId,\n  sourceAmount: z.string(),\n  destinationAmount: z.string(), // Expected output\n  minDestinationAmount: z.string(), // After slippage\n\n  // Costs\n  totalGasCost: z.string(), // In USD\n  totalProtocolFees: z.string(), // In USD\n  totalBridgeFees: z.string(), // In USD\n  totalCost: z.string(), // Total fees in USD\n\n  // Time\n  estimatedTime: z.number(), // Total seconds\n\n  // Quality metrics\n  priceImpact: z.string(), // Percentage\n  confidence: z.number().min(0).max(100), // Route reliability score\n\n  // Metadata\n  optimization: OptimizationStrategy,\n  warnings: z.array(z.string()),\n  createdAt: z.number(),\n  expiresAt: z.number(),\n});\nexport type Route = z.infer<typeof Route>;\n\n/**\n * Route comparison result\n */\nexport const RouteComparison = z.object({\n  bestRoute: Route,\n  alternatives: z.array(Route),\n  comparison: z.object({\n    costSavings: z.string(), // Best vs worst\n    timeDifference: z.number(), // Seconds\n    riskDifference: z.number(), // Confidence difference\n  }),\n});\nexport type RouteComparison = z.infer<typeof RouteComparison>;\n\n/**\n * Route validation result\n */\nexport const RouteValidation = z.object({\n  valid: z.boolean(),\n  errors: z.array(z.object({\n    step: z.number().optional(),\n    code: z.string(),\n    message: z.string(),\n  })),\n  warnings: z.array(z.object({\n    step: z.number().optional(),\n    code: z.string(),\n    message: z.string(),\n  })),\n});\nexport type RouteValidation = z.infer<typeof RouteValidation>;\n\n/**\n * Network graph edge (for routing algorithms)\n */\nexport interface GraphEdge {\n  from: ChainId;\n  to: ChainId;\n  fromAsset: AssetId;\n  toAsset: AssetId;\n  protocol: ProtocolId;\n  type: RouteStepType;\n  cost: number; // Normalized cost for algorithm\n  liquidity: string;\n  maxAmount: string;\n  minAmount: string;\n  estimatedTime: number;\n}\n\n/**\n * Network graph node\n */\nexport interface GraphNode {\n  chain: ChainId;\n  asset: AssetId;\n  edges: GraphEdge[];\n}\n\n/**\n * Routing graph\n */\nexport interface RoutingGraph {\n  nodes: Map<string, GraphNode>; // key: chain:asset\n  edges: GraphEdge[];\n  lastUpdated: number;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-XKFKUWJY.js

@@ -0,0 +1,504 @@
+// src/execution/types.ts
+import { z } from "zod";
+var TransactionStatus = z.enum([
+  "pending",
+  "submitted",
+  "confirmed",
+  "failed",
+  "replaced"
+]);
+var MevProtectionStrategy = z.enum([
+  "none",
+  // No protection
+  "flashbots",
+  // Use Flashbots (Ethereum)
+  "private_mempool",
+  // Use private mempool
+  "timing",
+  // Submit at optimal time
+  "splitting"
+  // Split into smaller transactions
+]);
+var TransactionRequest = z.object({
+  to: z.string(),
+  data: z.string(),
+  value: z.string().default("0"),
+  gasLimit: z.string(),
+  maxFeePerGas: z.string().optional(),
+  maxPriorityFeePerGas: z.string().optional(),
+  gasPrice: z.string().optional(),
+  nonce: z.number().optional(),
+  chainId: z.number()
+});
+var SignedTransaction = z.object({
+  raw: z.string(),
+  hash: z.string(),
+  from: z.string(),
+  to: z.string(),
+  nonce: z.number(),
+  gasLimit: z.string(),
+  value: z.string()
+});
+var TransactionReceipt = z.object({
+  hash: z.string(),
+  status: TransactionStatus,
+  blockNumber: z.number().optional(),
+  blockHash: z.string().optional(),
+  gasUsed: z.string().optional(),
+  effectiveGasPrice: z.string().optional(),
+  logs: z.array(z.object({
+    address: z.string(),
+    topics: z.array(z.string()),
+    data: z.string()
+  })).optional(),
+  timestamp: z.number()
+});
+var ExecutionStepResult = z.object({
+  stepId: z.string(),
+  status: TransactionStatus,
+  transaction: TransactionReceipt.optional(),
+  actualOutput: z.string().optional(),
+  error: z.string().optional(),
+  startedAt: z.number(),
+  completedAt: z.number().optional()
+});
+var ExecutionResult = z.object({
+  routeId: z.string(),
+  status: z.enum(["pending", "partial", "completed", "failed", "reverted"]),
+  steps: z.array(ExecutionStepResult),
+  actualOutput: z.string().optional(),
+  totalGasUsed: z.string().optional(),
+  totalGasCost: z.string().optional(),
+  error: z.string().optional(),
+  startedAt: z.number(),
+  completedAt: z.number().optional()
+});
+var ExecutionOptions = z.object({
+  // Gas settings
+  gasSpeed: z.enum(["slow", "standard", "fast", "instant"]).default("standard"),
+  maxGasPrice: z.string().optional(),
+  // MEV protection
+  mevProtection: MevProtectionStrategy.default("none"),
+  flashbotsRelay: z.string().optional(),
+  // Retry settings
+  maxRetries: z.number().default(3),
+  retryDelay: z.number().default(5e3),
+  // ms
+  // Timeout
+  timeout: z.number().default(3e5),
+  // 5 minutes
+  // Simulation
+  simulate: z.boolean().default(true),
+  // Approval handling
+  autoApprove: z.boolean().default(true),
+  approvalBuffer: z.string().default("0")
+  // Extra approval amount
+});
+var SimulationResult = z.object({
+  success: z.boolean(),
+  gasUsed: z.string(),
+  output: z.string().optional(),
+  error: z.string().optional(),
+  logs: z.array(z.object({
+    address: z.string(),
+    topics: z.array(z.string()),
+    data: z.string()
+  })),
+  stateChanges: z.array(z.object({
+    address: z.string(),
+    key: z.string(),
+    before: z.string(),
+    after: z.string()
+  })).optional()
+});
+
+// src/execution/builder.ts
+var CHAIN_IDS = {
+  "eip155:1": 1,
+  // Ethereum
+  "eip155:8453": 8453,
+  // Base
+  "eip155:42161": 42161,
+  // Arbitrum
+  "eip155:10": 10,
+  // Optimism
+  "eip155:137": 137,
+  // Polygon
+  "eip155:56": 56,
+  // BSC
+  "eip155:43114": 43114
+  // Avalanche
+};
+var FUNCTION_SELECTORS = {
+  // ERC20
+  transfer: "0xa9059cbb",
+  approve: "0x095ea7b3",
+  transferFrom: "0x23b872dd",
+  // Uniswap V2 Router
+  swapExactTokensForTokens: "0x38ed1739",
+  swapTokensForExactTokens: "0x8803dbee",
+  // Uniswap V3 Router
+  exactInputSingle: "0x414bf389",
+  exactInput: "0xc04b8d59",
+  // WETH
+  deposit: "0xd0e30db0",
+  withdraw: "0x2e1a7d4d"
+};
+var TransactionBuilder = class {
+  gasOracle;
+  config;
+  constructor(gasOracle, config = {}) {
+    this.gasOracle = gasOracle;
+    this.config = {
+      defaultGasBuffer: config.defaultGasBuffer ?? 20
+      // 20% buffer
+    };
+  }
+  /**
+   * Build all transactions for a route
+   */
+  async buildRoute(route, sender, options) {
+    const transactions = [];
+    for (const step of route.steps) {
+      const tx = await this.buildStep(step, sender, options);
+      transactions.push(tx);
+    }
+    return transactions;
+  }
+  /**
+   * Build a single step transaction
+   */
+  async buildStep(step, sender, options) {
+    const chainId = CHAIN_IDS[step.chain];
+    if (!chainId) {
+      throw new BuilderError(`Unsupported chain: ${step.chain}`, "UNSUPPORTED_CHAIN");
+    }
+    const gasPrice = await this.gasOracle.getGasPrice(step.chain);
+    const gasPriceWei = gasPrice[options.gasSpeed];
+    let finalGasPrice = gasPriceWei;
+    if (options.maxGasPrice && BigInt(gasPriceWei) > BigInt(options.maxGasPrice)) {
+      finalGasPrice = options.maxGasPrice;
+    }
+    const { data, value } = this.buildCalldata(step, sender);
+    const gasWithBuffer = this.applyGasBuffer(step.estimatedGas);
+    const isEip1559 = gasPrice.baseFee !== void 0;
+    const tx = {
+      to: step.contract,
+      data,
+      value: value ?? "0",
+      gasLimit: gasWithBuffer,
+      chainId
+    };
+    if (isEip1559 && gasPrice.priorityFee) {
+      tx.maxFeePerGas = finalGasPrice;
+      tx.maxPriorityFeePerGas = gasPrice.priorityFee[options.gasSpeed];
+    } else {
+      tx.gasPrice = finalGasPrice;
+    }
+    return tx;
+  }
+  /**
+   * Build approval transaction if needed
+   */
+  buildApproval(tokenAddress, spender, amount, _chainId, infinite = false) {
+    const approvalAmount = infinite ? "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" : BigInt(amount).toString(16).padStart(64, "0");
+    const data = FUNCTION_SELECTORS.approve + spender.slice(2).padStart(64, "0").toLowerCase() + approvalAmount;
+    return {
+      to: tokenAddress,
+      data
+    };
+  }
+  /**
+   * Build transfer transaction
+   */
+  buildTransfer(tokenAddress, recipient, amount) {
+    const data = FUNCTION_SELECTORS.transfer + recipient.slice(2).padStart(64, "0").toLowerCase() + BigInt(amount).toString(16).padStart(64, "0");
+    return {
+      to: tokenAddress,
+      data
+    };
+  }
+  /**
+   * Estimate required approvals for a route
+   */
+  getRequiredApprovals(route, _sender) {
+    const approvals = [];
+    const approvedPairs = /* @__PURE__ */ new Set();
+    for (const step of route.steps) {
+      if (step.type === "approve") continue;
+      const key = `${step.inputAsset}:${step.contract}`;
+      if (approvedPairs.has(key)) continue;
+      approvals.push({
+        token: step.inputAsset,
+        spender: step.contract,
+        amount: step.inputAmount
+      });
+      approvedPairs.add(key);
+    }
+    return approvals;
+  }
+  buildCalldata(step, sender) {
+    switch (step.type) {
+      case "transfer":
+        return this.buildTransferCalldata(step);
+      case "approve":
+        return this.buildApproveCalldata(step);
+      case "swap":
+        return this.buildSwapCalldata(step, sender);
+      case "bridge":
+        return this.buildBridgeCalldata(step, sender);
+      case "wrap":
+        return this.buildWrapCalldata(step);
+      case "unwrap":
+        return this.buildUnwrapCalldata(step);
+      case "deposit":
+      case "withdraw":
+        return { data: step.calldata ?? "0x", value: step.value };
+      default:
+        throw new BuilderError(`Unknown step type: ${step.type}`, "UNKNOWN_STEP_TYPE");
+    }
+  }
+  buildTransferCalldata(step) {
+    const data = FUNCTION_SELECTORS.transfer + step.contract.slice(2).padStart(64, "0").toLowerCase() + BigInt(step.inputAmount).toString(16).padStart(64, "0");
+    return { data };
+  }
+  buildApproveCalldata(step) {
+    const data = FUNCTION_SELECTORS.approve + step.contract.slice(2).padStart(64, "0").toLowerCase() + BigInt(step.inputAmount).toString(16).padStart(64, "0");
+    return { data };
+  }
+  buildSwapCalldata(step, sender) {
+    const deadline = Math.floor(Date.now() / 1e3) + 1800;
+    const amountIn = BigInt(step.inputAmount).toString(16).padStart(64, "0");
+    const amountOutMin = BigInt(step.minOutputAmount).toString(16).padStart(64, "0");
+    const pathOffset = "00000000000000000000000000000000000000000000000000000000000000a0";
+    const to = sender.slice(2).padStart(64, "0").toLowerCase();
+    const deadlineHex = deadline.toString(16).padStart(64, "0");
+    const pathLength = "0000000000000000000000000000000000000000000000000000000000000002";
+    const token0 = step.inputAsset.slice(2).padStart(64, "0").toLowerCase();
+    const token1 = step.outputAsset.slice(2).padStart(64, "0").toLowerCase();
+    const data = FUNCTION_SELECTORS.swapExactTokensForTokens + amountIn + amountOutMin + pathOffset + to + deadlineHex + pathLength + token0 + token1;
+    return { data };
+  }
+  buildBridgeCalldata(step, _sender) {
+    return {
+      data: step.calldata ?? "0x",
+      value: step.value
+    };
+  }
+  buildWrapCalldata(step) {
+    return {
+      data: FUNCTION_SELECTORS.deposit,
+      value: step.inputAmount
+    };
+  }
+  buildUnwrapCalldata(step) {
+    const data = FUNCTION_SELECTORS.withdraw + BigInt(step.inputAmount).toString(16).padStart(64, "0");
+    return { data };
+  }
+  applyGasBuffer(gasEstimate) {
+    const gas = BigInt(gasEstimate);
+    const buffer = BigInt(this.config.defaultGasBuffer);
+    return (gas + gas * buffer / 100n).toString();
+  }
+};
+var BuilderError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "BuilderError";
+    this.code = code;
+  }
+};
+
+// src/execution/mev.ts
+var MevProtection = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      flashbotsRelay: config.flashbotsRelay ?? "https://relay.flashbots.net",
+      privateRpcUrls: config.privateRpcUrls ?? {},
+      simulationRpc: config.simulationRpc ?? "",
+      maxBundleSize: config.maxBundleSize ?? 5
+    };
+  }
+  /**
+   * Apply MEV protection to a transaction
+   */
+  async protect(_tx, signedTx, strategy, chain) {
+    switch (strategy) {
+      case "none":
+        return { method: "public_mempool" };
+      case "flashbots":
+        return this.useFlashbots(signedTx, chain);
+      case "private_mempool":
+        return this.usePrivateMempool(signedTx, chain);
+      case "timing":
+        return this.useTimingProtection(signedTx, chain);
+      case "splitting":
+        return { method: "splitting", bundleHash: "split-not-implemented" };
+      default:
+        return { method: "public_mempool" };
+    }
+  }
+  /**
+   * Submit transaction bundle to Flashbots
+   */
+  async submitBundle(signedTxs, targetBlock, _chain) {
+    if (signedTxs.length > this.config.maxBundleSize) {
+      return {
+        bundleHash: "",
+        submitted: false,
+        error: `Bundle size ${signedTxs.length} exceeds max ${this.config.maxBundleSize}`
+      };
+    }
+    const bundleHash = this.generateBundleHash(signedTxs, targetBlock);
+    const simulationResult = {
+      success: true,
+      gasUsed: signedTxs.reduce((sum, tx) => sum + BigInt(tx.gasLimit), 0n).toString(),
+      logs: []
+    };
+    return {
+      bundleHash,
+      submitted: true,
+      simulationResult
+    };
+  }
+  /**
+   * Simulate transaction without executing
+   */
+  async simulate(tx, _chain) {
+    return {
+      success: true,
+      gasUsed: tx.gasLimit,
+      logs: []
+    };
+  }
+  /**
+   * Estimate MEV risk for a transaction
+   */
+  estimateMevRisk(tx, _chain) {
+    const value = BigInt(tx.value);
+    const recommendations = [];
+    let riskLevel = "low";
+    let estimatedMevCost = "0";
+    const isSwap = tx.data.startsWith("0x38ed") || // swapExactTokensForTokens
+    tx.data.startsWith("0x8803") || // swapTokensForExactTokens
+    tx.data.startsWith("0x414b") || // V3 exactInputSingle
+    tx.data.startsWith("0xc04b");
+    if (isSwap) {
+      riskLevel = "high";
+      estimatedMevCost = (value * 3n / 1000n).toString();
+      recommendations.push("Use Flashbots or private mempool");
+      recommendations.push("Consider splitting into smaller transactions");
+      recommendations.push("Set tight slippage tolerance");
+    }
+    if (value > BigInt("1000000000000000000000")) {
+      riskLevel = "medium";
+      recommendations.push("Consider using private mempool");
+    }
+    if (tx.data.startsWith("0x095e")) {
+      riskLevel = "medium";
+      recommendations.push("Bundle approval with swap in same block");
+    }
+    return { riskLevel, estimatedMevCost, recommendations };
+  }
+  /**
+   * Get optimal block for transaction submission
+   */
+  getOptimalSubmissionTime(_chain) {
+    return {
+      targetBlock: 0,
+      // Next block
+      delay: 0,
+      reason: "Immediate submission recommended"
+    };
+  }
+  /**
+   * Check if Flashbots is available for a chain
+   */
+  isFlashbotsAvailable(chain) {
+    return chain === "eip155:1";
+  }
+  /**
+   * Get private RPC URL for a chain
+   */
+  getPrivateRpcUrl(chain) {
+    return this.config.privateRpcUrls[chain];
+  }
+  async useFlashbots(signedTx, chain) {
+    if (!this.isFlashbotsAvailable(chain)) {
+      return { method: "public_mempool" };
+    }
+    const bundleResult = await this.submitBundle([signedTx], 0, chain);
+    return {
+      method: "flashbots",
+      endpoint: this.config.flashbotsRelay,
+      bundleHash: bundleResult.bundleHash
+    };
+  }
+  async usePrivateMempool(_signedTx, chain) {
+    const privateRpc = this.getPrivateRpcUrl(chain);
+    if (!privateRpc) {
+      return { method: "public_mempool" };
+    }
+    return {
+      method: "private_mempool",
+      endpoint: privateRpc
+    };
+  }
+  async useTimingProtection(_signedTx, chain) {
+    const timing = this.getOptimalSubmissionTime(chain);
+    if (timing.delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, timing.delay));
+    }
+    return { method: "timing_protected" };
+  }
+  generateBundleHash(txs, targetBlock) {
+    const txHashes = txs.map((tx) => tx.hash).join("");
+    return `0x${this.simpleHash(txHashes + targetBlock.toString())}`;
+  }
+  simpleHash(input) {
+    let hash = 0;
+    for (let i = 0; i < input.length; i++) {
+      const char = input.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16).padStart(64, "0");
+  }
+};
+function createMevProtectedOptions(chain, value) {
+  if (chain === "eip155:1" && BigInt(value) > BigInt("100000000000000000000")) {
+    return {
+      strategy: "flashbots",
+      reason: "High value transaction on Ethereum mainnet"
+    };
+  }
+  if (chain.startsWith("eip155:") && ["8453", "42161", "10"].some((id) => chain.includes(id))) {
+    return {
+      strategy: "none",
+      reason: "L2 chain with limited MEV activity"
+    };
+  }
+  return {
+    strategy: "private_mempool",
+    reason: "Default protection for moderate value transactions"
+  };
+}
+
+export {
+  TransactionStatus,
+  MevProtectionStrategy,
+  TransactionRequest,
+  SignedTransaction,
+  TransactionReceipt,
+  ExecutionStepResult,
+  ExecutionResult,
+  ExecutionOptions,
+  SimulationResult,
+  TransactionBuilder,
+  BuilderError,
+  MevProtection,
+  createMevProtectedOptions
+};
+//# sourceMappingURL=chunk-XKFKUWJY.js.map