hermes-swap 0.0.31 → 0.0.32

package/dist/cjs/index.d.ts

@@ -1,5 +1,6 @@
 import type { IExpectParams, ISwapParams, IBridgeParams, ISwapAndBridgeParams, IReceipt, IConfig, IExpectPayload, IRouterPath, SupportContracts } from './types.js';
 import { ChainNameEnum, AddressConst, DexType, BridgeType, IEstimateType } from './types.js';
+import { TransactionRequest } from 'ethers';
 export type { IExpectParams, ISwapParams, IBridgeParams, ISwapAndBridgeParams, IReceipt, IConfig, IExpectPayload, IRouterPath, SupportContracts };
 export { ChainNameEnum, AddressConst, DexType, BridgeType, IEstimateType };
 declare class Hermes {
@@ -10,7 +11,7 @@ declare class Hermes {
     private aggregatorAddressMap;
     constructor(config: IConfig);
     expect(params: IExpectParams): Promise<bigint>;
-    swap(params: ISwapParams): Promise<IReceipt>;
+    swap(params: ISwapParams, txReq?: TransactionRequest): Promise<IReceipt>;
     /**
      * 生成 swap 的 calldata
      */
@@ -18,9 +19,9 @@ declare class Hermes {
         to: string;
         data: string;
     };
-    bridge(params: IBridgeParams): Promise<IReceipt>;
+    bridge(params: IBridgeParams, txReq?: TransactionRequest): Promise<IReceipt>;
     estimateBridgeFee(params: IBridgeParams): Promise<bigint>;
-    swapAndBridge(params: ISwapAndBridgeParams): Promise<IReceipt>;
+    swapAndBridge(params: ISwapAndBridgeParams, txReq?: TransactionRequest): Promise<IReceipt>;
     estimateGas(estimateType: IEstimateType, params: IBridgeParams | ISwapParams | ISwapAndBridgeParams): Promise<bigint>;
     getAggregatorSupportContracts(chain: ChainNameEnum): Promise<SupportContracts[]>;
     getQuoterSupportContracts(chain: ChainNameEnum): Promise<SupportContracts[]>;
@@ -32,6 +33,10 @@ declare class Hermes {
         data: string;
         value: bigint;
     };
+    private resolveGasLimit;
+    private resolveNonce;
+    private resolvePricing;
+    private sanitizePricing;
     private checkIsEnoughToken;
     private validateParams;
     private getQuoterAddress;

package/dist/cjs/index.js

@@ -40,7 +40,6 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 var import_types = require("./types.js");
 var import_ethers = require("ethers");
-var import_ethers2 = require("ethers");
 var import_quoter = __toESM(require("./abis/quoter.js"));
 var import_aggregator = __toESM(require("./abis/aggregator.js"));
 var Hermes = class {
@@ -73,7 +72,7 @@ var Hermes = class {
     if (!address) {
       throw new Error(`Quoter address not found for chain: ${params.chain}`);
     }
-    const quoter = new import_ethers2.Contract(address, import_quoter.default, wallet);
+    const quoter = new import_ethers.Contract(address, import_quoter.default, wallet);
     const quoteParams = params.path.map((p) => ({
       dexType: p.dexType,
       pool: p.poolAddress,
@@ -87,7 +86,7 @@ var Hermes = class {
     }
     return amountOutList[amountOutList.length - 1];
   }
-  async swap(params) {
+  async swap(params, txReq = {}) {
     this.validateParams(params);
     if (!params.path.length) {
       throw new Error("Swap path not provided");
@@ -99,7 +98,7 @@ var Hermes = class {
     if (!wallet) {
       throw new Error(`Wallet not configured for chain: ${params.chain}`);
     }
-    const aggregator = new import_ethers2.Contract(aggregatorAddress, import_aggregator.default, wallet);
+    const aggregator = new import_ethers.Contract(aggregatorAddress, import_aggregator.default, wallet);
     const swapParams = params.path.map((pathItem) => ({
       dexType: pathItem.dexType,
       pool: pathItem.poolAddress,
@@ -107,7 +106,7 @@ var Hermes = class {
       toCoin: pathItem.toCoinAddress,
       extra: pathItem.extra ?? "0x"
     }));
-    const erc20 = new import_ethers2.Contract(fromTokenAddress, ["function balanceOf(address) view returns (uint256)", "function allowance(address, address) view returns (uint256)"], wallet);
+    const erc20 = new import_ethers.Contract(fromTokenAddress, ["function balanceOf(address) view returns (uint256)", "function allowance(address, address) view returns (uint256)"], wallet);
     const userBalance = await erc20.balanceOf(params.user);
     if (userBalance < params.amountInWei) {
       throw new Error("Insufficient balance for swap");
@@ -116,22 +115,21 @@ var Hermes = class {
     if (currentAllowance < params.amountInWei) {
       throw new Error("Insufficient allowance token amount for swap");
     }
+    let estimateGas;
+    const { gasLimit: _ignore, ...estimationOverrides } = txReq;
     try {
-      const gas = await aggregator.getFunction("swap").estimateGas(params.user, params.amountInWei, swapParams, params.minAmountOutList, { from: wallet.address });
+      estimateGas = await aggregator.swap.estimateGas(params.user, params.amountInWei, swapParams, params.minAmountOutList, estimationOverrides);
     } catch (error) {
       console.warn("Aggregator estimateGas.swap failed", error);
       throw error;
     }
-    let txResponse;
-    try {
-      txResponse = await aggregator.getFunction("swap")(params.user, params.amountInWei, swapParams, params.minAmountOutList, { from: wallet.address });
-    } catch (error) {
-      console.error("Aggregator swap transaction failed", error);
-      throw error;
-    }
+    txReq = this.resolveGasLimit(txReq, estimateGas);
+    txReq = await this.resolveNonce(wallet.provider, wallet.address, txReq);
+    txReq = await this.resolvePricing(wallet.provider, txReq);
+    let txResponse = await aggregator.swap(params.user, params.amountInWei, swapParams, params.minAmountOutList, txReq);
     const receipt = await txResponse.wait();
     const iface = new import_ethers.ethers.Interface(import_aggregator.default);
-    let amountOut = params.amountInWei;
+    let amountOut = null;
     for (const log of receipt.logs) {
       if (log.address.toLowerCase() === aggregatorAddress.toLowerCase()) {
         try {
@@ -144,6 +142,9 @@ var Hermes = class {
         }
       }
     }
+    if (!amountOut) {
+      throw new Error(`Swapped event not found: ${receipt.hash}`);
+    }
     return {
       fromToken: fromTokenAddress,
       toToken: toTokenAddress,
@@ -178,7 +179,7 @@ var Hermes = class {
       data: calldata
     };
   }
-  async bridge(params) {
+  async bridge(params, txReq = {}) {
     this.validateParams(params);
     const aggregatorAddress = this.getAggregatorAddress(params.chain);
     const wallet = this.walletMap.get(params.chain);
@@ -198,7 +199,7 @@ var Hermes = class {
         throw new Error("Insufficient native balance for bridge fee");
       }
     }
-    const aggregator = new import_ethers2.Contract(aggregatorAddress, import_aggregator.default, wallet);
+    const aggregator = new import_ethers.Contract(aggregatorAddress, import_aggregator.default, wallet);
     const bridgeArgs = {
       bridge: params.bridgeType,
       token: params.tokenAddress,
@@ -208,33 +209,31 @@ var Hermes = class {
       destUser: params.destUser,
       extra: params.extra ?? "0x"
     };
-    const txOverrides = {
-      from: wallet.address,
-      value: params.bridgeFee
-    };
-    try {
-      await aggregator.bridge.estimateGas(params.user, bridgeArgs, txOverrides);
-    } catch (error) {
-      console.error("Bridge gas estimation reverted", error);
-      throw error;
+    if (txReq.value == null) {
+      txReq = { ...txReq, value: params.bridgeFee };
     }
-    let txResponse;
+    let estimateGas;
+    const { gasLimit: _ignore, ...estimationOverrides } = txReq;
     try {
-      txResponse = await aggregator.bridge(params.user, bridgeArgs, txOverrides);
+      estimateGas = await aggregator.bridge.estimateGas(params.user, bridgeArgs, estimationOverrides);
     } catch (error) {
-      console.error("Aggregator swap transaction failed", error);
+      console.error("Bridge gas estimation reverted", error);
       throw error;
     }
-    const receipt = {
+    txReq = this.resolveGasLimit(txReq, estimateGas);
+    txReq = await this.resolveNonce(wallet.provider, wallet.address, txReq);
+    txReq = await this.resolvePricing(wallet.provider, txReq);
+    let response = await aggregator.bridge(params.user, bridgeArgs, txReq);
+    const txReceipt = await response.wait();
+    return {
       fromToken: params.tokenAddress,
       toToken: params.tokenAddress,
       amountOut: params.amountInWei,
-      hash: txResponse.hash,
-      from: txResponse.from,
-      to: txResponse.to,
-      logs: txResponse.logs
+      hash: txReceipt.hash,
+      from: txReceipt.from,
+      to: txReceipt.to,
+      logs: txReceipt.logs
     };
-    return Promise.resolve(receipt);
   }
   async estimateBridgeFee(params) {
     this.validateParams(params);
@@ -246,7 +245,7 @@ var Hermes = class {
     if (!address) {
       throw new Error(`Quoter address not found for chain: ${params.chain}`);
     }
-    const quoter = new import_ethers2.Contract(address, import_quoter.default, wallet);
+    const quoter = new import_ethers.Contract(address, import_quoter.default, wallet);
     const bridgeArgs = {
       bridge: params.bridgeType,
       token: params.tokenAddress,
@@ -259,7 +258,7 @@ var Hermes = class {
     const bridgeFee = await quoter.quoteBridge.staticCall(bridgeArgs, { from: wallet.address });
     return bridgeFee;
   }
-  async swapAndBridge(params) {
+  async swapAndBridge(params, txReq = {}) {
     this.validateParams(params);
     const aggregatorAddress = this.getAggregatorAddress(params.chain);
     const wallet = this.walletMap.get(params.chain);
@@ -286,40 +285,49 @@ var Hermes = class {
       destUser: params.destUser,
       extra: params.extra ?? "0x"
     };
-    const txOverrides = {
-      from: wallet.address,
-      value: params.bridgeFee
-    };
-    const aggregator = new import_ethers2.Contract(aggregatorAddress, import_aggregator.default, wallet);
-    try {
-      await aggregator.swapAndBridge.estimateGas(params.user, params.amountInWei, swapParams, params.minAmountOutList, bridgeArgs, txOverrides);
-    } catch (error) {
-      console.error("Bridge gas estimation reverted", error);
-      throw error;
+    if (txReq.value == null) {
+      txReq = { ...txReq, value: params.bridgeFee };
+    }
+    const { gasLimit: _ignore, ...estimationOverrides } = txReq;
+    const aggregator = new import_ethers.Contract(aggregatorAddress, import_aggregator.default, wallet);
+    let estimateGas = await aggregator.swapAndBridge.estimateGas(params.user, params.amountInWei, swapParams, params.minAmountOutList, bridgeArgs, estimationOverrides);
+    txReq = this.resolveGasLimit(txReq, estimateGas);
+    txReq = await this.resolveNonce(wallet.provider, wallet.address, txReq);
+    txReq = await this.resolvePricing(wallet.provider, txReq);
+    let response = await aggregator.swapAndBridge(params.user, params.amountInWei, swapParams, params.minAmountOutList, bridgeArgs, txReq);
+    const txReceipt = await response.wait();
+    const iface = new import_ethers.ethers.Interface(import_aggregator.default);
+    let outputAmountWei = null;
+    for (const log of txReceipt.logs) {
+      if (log.address.toLowerCase() === aggregatorAddress.toLowerCase()) {
+        try {
+          const parsed = iface.parseLog(log);
+          if (parsed && parsed.name === "SwapAndBridge" && parsed.args && parsed.args.amountOut !== void 0) {
+            outputAmountWei = parsed.args.amountOut;
+            break;
+          }
+        } catch {
+        }
+      }
     }
-    let txResponse;
-    try {
-      txResponse = await aggregator.swapAndBridge(params.user, params.amountInWei, swapParams, params.minAmountOutList, bridgeArgs, txOverrides);
-    } catch (error) {
-      console.error("Aggregator swap and bridge transaction failed", error);
-      throw error;
+    if (!outputAmountWei) {
+      throw new Error(`SwapAndBridge event not found: ${txReceipt.hash}`);
     }
-    const receipt = {
+    return {
       fromToken: params.path[0].fromCoinAddress,
       toToken: params.path[params.path.length - 1].toCoinAddress,
-      amountOut: params.minAmountOutList[params.minAmountOutList.length - 1],
-      hash: txResponse.hash,
-      from: txResponse.from,
-      to: txResponse.to,
-      logs: txResponse.logs
+      amountOut: outputAmountWei,
+      hash: txReceipt.hash,
+      from: txReceipt.from,
+      to: txReceipt.to,
+      logs: txReceipt.logs
     };
-    return Promise.resolve(receipt);
   }
   async estimateGas(estimateType, params) {
     this.validateParams(params);
     const aggregatorAddress = this.getAggregatorAddress(params.chain);
     const wallet = this.walletMap.get(params.chain);
-    const aggregator = new import_ethers2.Contract(aggregatorAddress, import_aggregator.default, wallet);
+    const aggregator = new import_ethers.Contract(aggregatorAddress, import_aggregator.default, wallet);
     if (!wallet) {
       throw new Error(`Wallet not configured for chain: ${params.chain}`);
     }
@@ -396,7 +404,7 @@ var Hermes = class {
     if (!provider) {
       throw new Error(`Provider not configured for chain: ${chain}`);
     }
-    const aggregator = new import_ethers2.Contract(aggregatorAddress, import_aggregator.default, provider);
+    const aggregator = new import_ethers.Contract(aggregatorAddress, import_aggregator.default, provider);
     const addressList = await aggregator.getAddressList();
     if (!addressList.length) {
       return [];
@@ -418,7 +426,7 @@ var Hermes = class {
     if (!provider) {
       throw new Error(`Provider not configured for chain: ${chain}`);
     }
-    const quoter = new import_ethers2.Contract(quoterAddress, import_quoter.default, provider);
+    const quoter = new import_ethers.Contract(quoterAddress, import_quoter.default, provider);
     const addressList = await quoter.getAddressList();
     if (!addressList.length) {
       return [];
@@ -468,14 +476,54 @@ var Hermes = class {
       value: params.bridgeFee
     };
   }
+  resolveGasLimit(txReq, estimateGas) {
+    if (txReq.gasLimit != null) {
+      return txReq;
+    }
+    return {
+      ...txReq,
+      gasLimit: estimateGas * 130n / 100n
+      // 上浮30%
+    };
+  }
+  async resolveNonce(provider, from, tx) {
+    if (tx.nonce != null)
+      return tx;
+    const nonce = await provider.getTransactionCount(from, "latest");
+    return { ...tx, nonce };
+  }
+  async resolvePricing(provider, tx) {
+    if (tx.gasPrice != null || tx.maxFeePerGas != null || tx.maxPriorityFeePerGas != null) {
+      return this.sanitizePricing(tx);
+    }
+    const fd = await provider.getFeeData();
+    if (fd.maxFeePerGas != null && fd.maxPriorityFeePerGas != null) {
+      return {
+        ...tx,
+        maxFeePerGas: fd.maxFeePerGas * 150n / 100n,
+        // 上浮50%
+        maxPriorityFeePerGas: fd.maxPriorityFeePerGas
+      };
+    }
+    if (fd.gasPrice != null) {
+      return { ...tx, gasPrice: fd.gasPrice };
+    }
+    return tx;
+  }
+  sanitizePricing(tx) {
+    if (tx.maxFeePerGas != null || tx.maxPriorityFeePerGas != null) {
+      const { gasPrice, ...rest } = tx;
+      return rest;
+    }
+    return tx;
+  }
   async checkIsEnoughToken(fromTokenAddress, userAddress, amountInWei, aggregatorAddress, wallet) {
-    const erc20 = new import_ethers2.Contract(fromTokenAddress, ["function balanceOf(address) view returns (uint256)", "function allowance(address, address) view returns (uint256)"], wallet);
+    const erc20 = new import_ethers.Contract(fromTokenAddress, ["function balanceOf(address) view returns (uint256)", "function allowance(address, address) view returns (uint256)"], wallet);
     const userBalance = await erc20.balanceOf(userAddress);
     if (userBalance < amountInWei) {
       throw new Error("Insufficient balance token amount");
     }
     const currentAllowance = await erc20.allowance(userAddress, aggregatorAddress);
-    console.log(currentAllowance);
     if (currentAllowance < amountInWei) {
       throw new Error("Insufficient allowance token amount");
     }

package/dist/cjs/types.d.ts

@@ -109,7 +109,9 @@ export declare enum DexType {
     VSDCRVWITHDRAW = "vsdCRV_withdraw",
     VSDCRVDEPOSIT = "vsdCRV_deposit",
     ASDCRVWITHDRAW = "asdCRV_withdraw",
-    ASDCRVDEPOSIT = "asdCRV_deposit"
+    ASDCRVDEPOSIT = "asdCRV_deposit",
+    SHADOWV3 = "shadowv3",
+    FRAXSWAPV2 = "fraxswapv2"
 }
 export declare enum IEstimateType {
     BRIDGE = "bridge",
@@ -122,7 +124,11 @@ export declare enum BridgeType {
     LAYERZEROV1ADADEQEMPTY = "layerzero_v1_adapter_eq_empty",
     LAYERZEROV1PKG = "layerzero_v1_pkg",
     LAYERZEROV1PKGNOMIN = "layerzero_v1_pkg_no_min",
-    LAYERZEROV1OHM = "layerzero_v1_ohm"
+    LAYERZEROV1OHM = "layerzero_v1_ohm",
+    ARBETHBRIDGE = "arb_eth_bridge",
+    ETHARBBRIDGE = "eth_arb_bridge",
+    ORIGINALTOKENBRIDGE = "original_token_bridge",
+    WRAPPEDTOKENBRIDGE = "wrapped_token_bridge"
 }
 export declare enum ChainNameEnum {
     ETH = "ETH",// Ethereum Mainnet
@@ -288,6 +294,13 @@ export declare const AddressConst: {
         eth: string;
         arb: string;
         base: string;
+        etherlink: string;
+    };
+    wfrax: {
+        fraxtal: string;
+    };
+    frxusd: {
+        fraxtal: string;
     };
     seth: {
         eth: string;
@@ -321,12 +334,19 @@ export declare const AddressConst: {
     emp: {
         base: string;
     };
+    eul: {
+        sonic: string;
+    };
     arb: {
         arb: string;
     };
     usdc: {
         arb: string;
         eth: string;
+        sonic: string;
+    };
+    link: {
+        eth: string;
     };
     ohm: {
         arb: string;

package/dist/cjs/types.js

@@ -43,6 +43,8 @@ var DexType = /* @__PURE__ */ ((DexType2) => {
   DexType2["VSDCRVDEPOSIT"] = "vsdCRV_deposit";
   DexType2["ASDCRVWITHDRAW"] = "asdCRV_withdraw";
   DexType2["ASDCRVDEPOSIT"] = "asdCRV_deposit";
+  DexType2["SHADOWV3"] = "shadowv3";
+  DexType2["FRAXSWAPV2"] = "fraxswapv2";
   return DexType2;
 })(DexType || {});
 var IEstimateType = /* @__PURE__ */ ((IEstimateType2) => {
@@ -58,6 +60,10 @@ var BridgeType = /* @__PURE__ */ ((BridgeType2) => {
   BridgeType2["LAYERZEROV1PKG"] = "layerzero_v1_pkg";
   BridgeType2["LAYERZEROV1PKGNOMIN"] = "layerzero_v1_pkg_no_min";
   BridgeType2["LAYERZEROV1OHM"] = "layerzero_v1_ohm";
+  BridgeType2["ARBETHBRIDGE"] = "arb_eth_bridge";
+  BridgeType2["ETHARBBRIDGE"] = "eth_arb_bridge";
+  BridgeType2["ORIGINALTOKENBRIDGE"] = "original_token_bridge";
+  BridgeType2["WRAPPEDTOKENBRIDGE"] = "wrapped_token_bridge";
   return BridgeType2;
 })(BridgeType || {});
 var ChainNameEnum = /* @__PURE__ */ ((ChainNameEnum2) => {
@@ -220,7 +226,14 @@ var AddressConst = {
   weth: {
     eth: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
     arb: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
-    base: "0x4200000000000000000000000000000000000006"
+    base: "0x4200000000000000000000000000000000000006",
+    etherlink: "0xfc24f770F94edBca6D6f885E12d4317320BcB401"
+  },
+  wfrax: {
+    fraxtal: "0xFc00000000000000000000000000000000000002"
+  },
+  frxusd: {
+    fraxtal: "0xFc00000000000000000000000000000000000001"
   },
   seth: {
     eth: "0x5e74C9036fb86BD7eCdcb084a0673EFc32eA31cb"
@@ -255,12 +268,19 @@ var AddressConst = {
   emp: {
     base: "0x39D5313C3750140E5042887413bA8AA6145a9bd2"
   },
+  eul: {
+    sonic: "0x8e15C8D399e86d4FD7B427D42f06c60cDD9397e7"
+  },
   arb: {
     arb: "0x912CE59144191C1204E64559FE8253a0e49E6548"
   },
   usdc: {
     arb: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
-    eth: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+    eth: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    sonic: "0x29219dd400f2Bf60E5a23d13Be72B486D4038894"
+  },
+  link: {
+    eth: "0x514910771AF9Ca656af840dff83E8264EcF986CA"
   },
   ohm: {
     arb: "0xf0cb2dc0db5e6c66B9a70Ac27B06b878da017028"

package/dist/esm/index.d.ts

@@ -1,5 +1,6 @@
 import type { IExpectParams, ISwapParams, IBridgeParams, ISwapAndBridgeParams, IReceipt, IConfig, IExpectPayload, IRouterPath, SupportContracts } from './types.js';
 import { ChainNameEnum, AddressConst, DexType, BridgeType, IEstimateType } from './types.js';
+import { TransactionRequest } from 'ethers';
 export type { IExpectParams, ISwapParams, IBridgeParams, ISwapAndBridgeParams, IReceipt, IConfig, IExpectPayload, IRouterPath, SupportContracts };
 export { ChainNameEnum, AddressConst, DexType, BridgeType, IEstimateType };
 declare class Hermes {
@@ -10,7 +11,7 @@ declare class Hermes {
     private aggregatorAddressMap;
     constructor(config: IConfig);
     expect(params: IExpectParams): Promise<bigint>;
-    swap(params: ISwapParams): Promise<IReceipt>;
+    swap(params: ISwapParams, txReq?: TransactionRequest): Promise<IReceipt>;
     /**
      * 生成 swap 的 calldata
      */
@@ -18,9 +19,9 @@ declare class Hermes {
         to: string;
         data: string;
     };
-    bridge(params: IBridgeParams): Promise<IReceipt>;
+    bridge(params: IBridgeParams, txReq?: TransactionRequest): Promise<IReceipt>;
     estimateBridgeFee(params: IBridgeParams): Promise<bigint>;
-    swapAndBridge(params: ISwapAndBridgeParams): Promise<IReceipt>;
+    swapAndBridge(params: ISwapAndBridgeParams, txReq?: TransactionRequest): Promise<IReceipt>;
     estimateGas(estimateType: IEstimateType, params: IBridgeParams | ISwapParams | ISwapAndBridgeParams): Promise<bigint>;
     getAggregatorSupportContracts(chain: ChainNameEnum): Promise<SupportContracts[]>;
     getQuoterSupportContracts(chain: ChainNameEnum): Promise<SupportContracts[]>;
@@ -32,6 +33,10 @@ declare class Hermes {
         data: string;
         value: bigint;
     };
+    private resolveGasLimit;
+    private resolveNonce;
+    private resolvePricing;
+    private sanitizePricing;
     private checkIsEnoughToken;
     private validateParams;
     private getQuoterAddress;