hermes-swap 0.6.6 → 0.6.8

package/dist/cjs/aggregator.cjs

@@ -877,8 +877,19 @@ var _Aggregator = class {
   static isBenignBroadcastError(message) {
     return message.includes("already known") || message.includes("nonce too low") || message.includes("nonce has already been used") || message.includes("ALREADY_EXISTS") || message.includes("NONCE_EXPIRED");
   }
-  async waitForBundleInclusion(provider, txHash, maxTargetBlock, signal) {
-    const deadline = Date.now() + _Aggregator.BUNDLE_INCLUSION_TIMEOUT_MS;
+  async blockContainsTxHash(provider, blockNumber, txHash) {
+    try {
+      const block = await provider.getBlock(blockNumber, true);
+      if (!block)
+        return false;
+      if (block.transactions.some((hash) => hash === txHash))
+        return true;
+      return block.prefetchedTransactions.some((tx) => tx.hash === txHash);
+    } catch {
+      return false;
+    }
+  }
+  async waitForReceipt(provider, txHash, deadline, signal) {
     while (Date.now() < deadline) {
       if (signal == null ? void 0 : signal.aborted)
         return null;
@@ -888,12 +899,119 @@ var _Aggregator = class {
           return receipt;
       } catch {
       }
-      const currentBlock = await provider.getBlockNumber().catch(() => 0);
-      if (currentBlock > maxTargetBlock + 1)
-        return null;
-      await new Promise((r) => setTimeout(r, _Aggregator.BUNDLE_POLL_INTERVAL_MS));
+      await new Promise((r) => setTimeout(r, 200));
     }
-    return null;
+    try {
+      const receipt = await provider.getTransactionReceipt(txHash);
+      return receipt ? receipt : null;
+    } catch {
+      return null;
+    }
+  }
+  async waitForBundleInclusion(provider, txHash, targetBlocks, signal) {
+    const deadline = Date.now() + _Aggregator.BUNDLE_INCLUSION_TIMEOUT_MS;
+    const sortedTargetBlocks = [...targetBlocks].sort((a, b) => a - b);
+    const targetBlockSet = new Set(sortedTargetBlocks);
+    const maxTargetBlock = sortedTargetBlocks[sortedTargetBlocks.length - 1];
+    return new Promise((resolve) => {
+      let settled = false;
+      let lastObservedBlock = sortedTargetBlocks[0] - 1;
+      const checkedBlocks = /* @__PURE__ */ new Set();
+      let matchedTargetBlock = false;
+      let inspectionChain = Promise.resolve();
+      const cleanup = () => {
+        clearTimeout(timer);
+        provider.off("block", onBlock);
+      };
+      const finish = (receipt) => {
+        if (settled)
+          return;
+        settled = true;
+        cleanup();
+        resolve(receipt);
+      };
+      const scheduleInspect = (fromBlock, toBlock) => {
+        if (fromBlock > toBlock) {
+          if (checkedBlocks.size === targetBlockSet.size && lastObservedBlock >= maxTargetBlock) {
+            finish(null);
+          }
+          return;
+        }
+        inspectionChain = inspectionChain.then(() => inspectTargetBlocks(fromBlock, toBlock)).catch(() => {
+        });
+      };
+      const inspectTargetBlocks = async (fromBlock, toBlock) => {
+        if (settled || (signal == null ? void 0 : signal.aborted)) {
+          finish(null);
+          return;
+        }
+        for (let blockNumber = fromBlock; blockNumber <= toBlock; blockNumber++) {
+          if (settled || (signal == null ? void 0 : signal.aborted)) {
+            finish(null);
+            return;
+          }
+          if (!targetBlockSet.has(blockNumber) || checkedBlocks.has(blockNumber))
+            continue;
+          checkedBlocks.add(blockNumber);
+          const matched = await this.blockContainsTxHash(provider, blockNumber, txHash);
+          if (!matched)
+            continue;
+          matchedTargetBlock = true;
+          clearTimeout(timer);
+          const receipt = await this.waitForReceipt(provider, txHash, Date.now() + _Aggregator.TX_CONFIRM_TIMEOUT_MS, signal);
+          finish(receipt);
+          return;
+        }
+        if (checkedBlocks.size === targetBlockSet.size && lastObservedBlock >= maxTargetBlock) {
+          finish(null);
+        }
+      };
+      const onBlock = (blockNumber) => {
+        if (settled)
+          return;
+        const fromBlock = Math.max(lastObservedBlock + 1, sortedTargetBlocks[0]);
+        const toBlock = Math.min(blockNumber, maxTargetBlock);
+        if (blockNumber > lastObservedBlock) {
+          lastObservedBlock = blockNumber;
+        }
+        if (fromBlock > toBlock) {
+          if (checkedBlocks.size === targetBlockSet.size && lastObservedBlock >= maxTargetBlock) {
+            finish(null);
+          }
+          return;
+        }
+        scheduleInspect(fromBlock, toBlock);
+      };
+      const timer = setTimeout(async () => {
+        if (settled)
+          return;
+        if (matchedTargetBlock)
+          return;
+        const latestBlock = await provider.getBlockNumber().catch(() => lastObservedBlock);
+        if (latestBlock > lastObservedBlock) {
+          lastObservedBlock = latestBlock;
+        }
+        const toBlock = Math.min(latestBlock, maxTargetBlock);
+        scheduleInspect(sortedTargetBlocks[0], toBlock);
+        await inspectionChain;
+        finish(null);
+      }, _Aggregator.BUNDLE_INCLUSION_TIMEOUT_MS);
+      provider.on("block", onBlock);
+      provider.getBlockNumber().then(
+        (currentBlock) => {
+          if (settled)
+            return;
+          lastObservedBlock = currentBlock;
+          const fromBlock = sortedTargetBlocks[0];
+          const toBlock = Math.min(currentBlock, maxTargetBlock);
+          if (fromBlock <= toBlock) {
+            scheduleInspect(fromBlock, toBlock);
+          }
+        },
+        () => {
+        }
+      );
+    });
   }
   async sendSignedTxToChannels(chain, signedTx, txHash, channels) {
     const results = await Promise.all(
@@ -1141,8 +1259,7 @@ var _Aggregator = class {
       });
     });
     const abortController = new AbortController();
-    const maxTargetBlock = Math.max(...targetBlocks);
-    const inclusionPromise = this.waitForBundleInclusion(provider, txHash, maxTargetBlock, abortController.signal);
+    const inclusionPromise = this.waitForBundleInclusion(provider, txHash, targetBlocks, abortController.signal);
     const waitTs = Date.now();
     const [receipt] = await Promise.all([
       inclusionPromise,
@@ -1313,7 +1430,6 @@ Aggregator.SEQUENCER_CHAINS = new Set(
   Object.keys(_Aggregator.DEFAULT_SEQUENCER_RPC_BY_CHAIN)
 );
 Aggregator.TX_CONFIRM_TIMEOUT_MS = 12e4;
-Aggregator.BUNDLE_POLL_INTERVAL_MS = 500;
 Aggregator.BUNDLE_INCLUSION_TIMEOUT_MS = 3e4;
 var aggregator_default = Aggregator;
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/aggregator.d.ts

@@ -55,9 +55,10 @@ declare class Aggregator {
     estimateGas(estimateType: IEstimateType, params: IBridgeParams | ISwapByPathParams | ISwapAndBridgeParams | IBatchMultiSwapParams): Promise<bigint>;
     getAggregatorSupportContracts(chain: ChainNameEnum): Promise<SupportContracts[]>;
     private static readonly TX_CONFIRM_TIMEOUT_MS;
-    private static readonly BUNDLE_POLL_INTERVAL_MS;
     private static readonly BUNDLE_INCLUSION_TIMEOUT_MS;
     private static isBenignBroadcastError;
+    private blockContainsTxHash;
+    private waitForReceipt;
     private waitForBundleInclusion;
     private sendSignedTxToChannels;
     private raceForReceipt;

package/dist/cjs/index.d.ts

@@ -1,7 +1,7 @@
-import type { HermesTxRequest, IBatchMultiSwapParams, IBatchExpectParams, ISwapByPathParams, IExpectSplitOrderParams, IExpectSplitOrderResp, IBridgeParams, IBatchReceipt, IMultiSwapParams, IBatchMultiSwapAndBridgeParams, ISwapAndBridgeParams, IReceipt, IConfig, IBuilderConfig, IExpectPayload, IRouterPath, SupportContracts, IExpectByPathParams, IHermesSignalResponse, IHermesSignalRoute } from './types.js';
+import type { HermesTxRequest, IBatchMultiSwapParams, IBatchExpectParams, ISwapByPathParams, IExpectSplitOrderParams, IExpectSplitOrderResp, IBridgeParams, IBatchReceipt, IMultiSwapParams, IBatchMultiSwapAndBridgeParams, ISwapAndBridgeParams, IReceipt, IConfig, IBuilderConfig, IExpectPayload, IRouterPath, SupportContracts, IExpectByPathParams, IHermesSignalResponse, IHermesSignalQuoteBestData, IHermesSignalRoute } from './types.js';
 import { ChainNameEnum, AddressConst, DexType, BridgeType, IEstimateType, LayerZeroV1ChainIdMap, LayerZeroV1ChainNameMap, LayerZeroV2ChainIdMap, LayerZeroV2ChainNameMap } from './types.js';
 import { TransactionRequest } from 'ethers';
-export type { HermesTxRequest, IBatchMultiSwapAndBridgeParams, IExpectSplitOrderParams, IExpectSplitOrderResp, IMultiSwapParams, IBatchMultiSwapParams, IBatchExpectParams, IBatchReceipt, ISwapByPathParams as ISwapParams, IBridgeParams, ISwapAndBridgeParams, IReceipt, IConfig, IBuilderConfig, IExpectPayload, IRouterPath, SupportContracts, IHermesSignalResponse, IHermesSignalRoute, };
+export type { HermesTxRequest, IBatchMultiSwapAndBridgeParams, IExpectSplitOrderParams, IExpectSplitOrderResp, IMultiSwapParams, IBatchMultiSwapParams, IBatchExpectParams, IBatchReceipt, ISwapByPathParams as ISwapParams, IBridgeParams, ISwapAndBridgeParams, IReceipt, IConfig, IBuilderConfig, IExpectPayload, IRouterPath, SupportContracts, IHermesSignalResponse, IHermesSignalQuoteBestData, IHermesSignalRoute, };
 import { BundleNotIncludedError, TransactionRevertedError } from './types.js';
 export { ChainNameEnum, AddressConst, DexType, BridgeType, IEstimateType, LayerZeroV1ChainIdMap, LayerZeroV1ChainNameMap, LayerZeroV2ChainIdMap, LayerZeroV2ChainNameMap, BundleNotIncludedError, TransactionRevertedError };
 declare class Hermes {

package/dist/cjs/provider.cjs

@@ -32,6 +32,7 @@ var Provider = class {
     for (const [chainName, rpc] of Object.entries(this.config.rpc)) {
       const chain = chainName;
       const provider = new import_ethers.ethers.JsonRpcProvider(rpc.url);
+      provider.pollingInterval = 500;
       this.providerMap.set(chain, provider);
       if (rpc.privateKey) {
         this.walletMap.set(chain, new import_ethers.ethers.Wallet(rpc.privateKey, provider));

package/dist/cjs/quoter.cjs

@@ -88,7 +88,7 @@ var Quoter = class {
       if (raw.code !== 200) {
         throw new Error(`Hermes Signal API 错误 [${raw.code}]`);
       }
-      const allocations = (_a = raw.data) == null ? void 0 : _a.allocations;
+      const allocations = (_a = raw.data) == null ? void 0 : _a.route_allocation;
       if (!Array.isArray(allocations)) {
         throw new Error(`Invalid response data: ${JSON.stringify(raw.data)}`);
       }

package/dist/cjs/types.d.ts

@@ -149,10 +149,11 @@ export interface IHermesSignalResponse<T> {
     data: T;
 }
 export interface IHermesSignalRoute {
-    chain: 'ETH';
+    chain: string;
     poolStepConfig: Array<{
         dexType: string;
         poolAddress: string;
+        poolId?: string;
         fromCoinAddress: string;
         toCoinAddress: string;
         extra?: string;
@@ -161,6 +162,13 @@ export interface IHermesSignalRoute {
     amountOutWei: string;
     blockNumber: number;
 }
+export interface IHermesSignalQuoteBestData {
+    amount_in: string;
+    amount_out: string;
+    route_allocation: IHermesSignalRoute[];
+    allocations: IHermesSignalRoute[];
+    elapsed_ms: number;
+}
 export declare enum DexType {
     FX = "f(x)",
     UNISWAPV2 = "uniswapv2",

package/dist/esm/aggregator.d.ts

@@ -55,9 +55,10 @@ declare class Aggregator {
     estimateGas(estimateType: IEstimateType, params: IBridgeParams | ISwapByPathParams | ISwapAndBridgeParams | IBatchMultiSwapParams): Promise<bigint>;
     getAggregatorSupportContracts(chain: ChainNameEnum): Promise<SupportContracts[]>;
     private static readonly TX_CONFIRM_TIMEOUT_MS;
-    private static readonly BUNDLE_POLL_INTERVAL_MS;
     private static readonly BUNDLE_INCLUSION_TIMEOUT_MS;
     private static isBenignBroadcastError;
+    private blockContainsTxHash;
+    private waitForReceipt;
     private waitForBundleInclusion;
     private sendSignedTxToChannels;
     private raceForReceipt;