@hyperbridge/sdk 2.8.0 → 2.8.2

package/dist/node/{intents-helpers-gyGREuyu.d.cts → intents-helpers-D_km9I2f.d.cts}

@@ -924,6 +924,11 @@ interface ChainConfigData {
         USDT: number;
         cNGN?: number;
         EXT?: number;
+        ZARP?: number;
+        EURC?: number;
+        XSGD?: number;
+        TRYB?: number;
+        USDR?: number;
     };
     tokenStorageSlots?: {
         USDT?: {
@@ -942,6 +947,30 @@ interface ChainConfigData {
             balanceSlot: number;
             allowanceSlot: number;
         };
+        cNGN?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        ZARP?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        EURC?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        XSGD?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        TRYB?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        USDR?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
     };
     addresses: {
         IntentGateway?: `0x${string}`;
@@ -1442,16 +1471,37 @@ declare class IntentsCoprocessor {
     /**
      * Signs and sends an extrinsic. Submissions are serialised through {@link submissionQueue} so
      * concurrent calls never collide on the substrate account nonce — each extrinsic reaches a block
-     * before the next is signed.
+     * (or is confirmed still pooled and returned as `pending`) before the next is signed; auto-nonce
+     * via `system.accountNextIndex` counts pooled extrinsics, so a pending one is never re-used.
      */
     private signAndSendExtrinsic;
     /**
      * Signs and sends an extrinsic, handling status updates and errors.
      * Implements retry logic with progressive tip increases for stuck transactions.
+     *
+     * A retry only happens when the previous attempt verifiably went nowhere. Once an attempt's
+     * extrinsic is known to be pooled (`pending`), re-signing the same call would race our own
+     * submission: the copy either bounces off the pool (1014, same nonce below the replacement
+     * priority bump) or — if the original lands first, freeing the nonce — executes as a duplicate
+     * and fails on-chain (e.g. `BidNotFound` for a retraction). Neither can succeed, so the pending
+     * result is returned for the caller to confirm later.
      */
     private sendExtrinsicWithRetries;
     /**
-     * Sends an extrinsic with a timeout
+     * Classifies a submission rejection. Codes 1013 ("already imported") and 1014 ("priority is
+     * too low") both mean a copy of this account+nonce is already in the pool — almost always our
+     * own earlier attempt whose watch handle didn't confirm cleanly. That extrinsic is in flight;
+     * resubmitting can only bounce again or land a duplicate, so these are surfaced as `pending`
+     * rather than failure.
+     */
+    private classifySubmissionError;
+    /**
+     * Sends an extrinsic with a timeout.
+     *
+     * A timeout is only a failure when the extrinsic never made it into the transaction pool.
+     * Once a pool-entry status (Future/Ready/Broadcast/Retracted) has been seen, the extrinsic is
+     * in flight and may well execute after the watch is abandoned — the result is then `pending`,
+     * telling the caller to confirm the outcome later instead of re-signing the same call.
      */
     private sendWithTimeout;
     /**
@@ -2948,6 +2998,15 @@ interface BidSubmissionResult {
      * Error message if submission failed
      */
     error?: string;
+    /**
+     * The extrinsic is (or may still be) in the transaction pool: it was accepted but its
+     * inclusion was not observed before the watch timed out, or a resubmission bounced off an
+     * earlier copy already pooled (RPC 1013/1014). Only meaningful when `success` is false —
+     * the operation is in flight, not failed, and must not be re-signed with the same nonce.
+     * Callers should confirm the outcome later (e.g. re-check on-chain state) instead of
+     * treating this as a terminal failure.
+     */
+    pending?: boolean;
 }
 /**
  * Represents a storage entry from pallet-intents Bids storage
@@ -4638,10 +4697,14 @@ interface LpBalance {
     tokenAddress: HexString;
     balance: bigint;
 }
-/** One verified solver behind a leg's quote. */
+/** One verified solver behind a leg's quote, holding inventory to deliver it. */
 interface PhantomLegBidder {
     solver: HexString;
-    /** The solver's output-token inventory on the destination chain — its weight in the median. */
+    /**
+     * The solver's output-token inventory on the destination chain — its weight in the median.
+     * Always greater than zero: a solver quoting a leg it holds none of is dropped, not recorded
+     * at zero, since it can deliver nothing at any price.
+     */
     weight: bigint;
     /**
      * Source chains the solver's signed paymasterAndData declaration accepts payment from. Null
@@ -4658,13 +4721,18 @@ interface PhantomLegAggregation {
     lowestPrice: bigint;
     highestPrice: bigint;
     medianPrice: bigint;
+    /** Backed quotes behind the price. Quotes from solvers holding no inventory are not counted. */
     bidCount: number;
-    /** The verified solvers quoting this leg; bidCount === bidders.length. */
+    /** The verified, inventory-backed solvers quoting this leg; bidCount === bidders.length. */
     bidders: PhantomLegBidder[];
 }
 /** The aggregated result for a single phantom order's bid window. */
 interface PhantomAggregation {
-    /** One entry per leg that at least one solver quoted; legs nobody quoted are absent. */
+    /**
+     * One entry per leg that at least one solver quoted AND at least one of those quotes is backed
+     * by output-token inventory on the destination chain. Legs nobody quoted are absent, and so are
+     * legs every bidder quoted on zero inventory — neither is a price anyone could trade against.
+     */
     legs: PhantomLegAggregation[];
     lpBalances: LpBalance[];
 }

package/dist/node/{intents-helpers-gyGREuyu.d.ts → intents-helpers-D_km9I2f.d.ts}

@@ -924,6 +924,11 @@ interface ChainConfigData {
         USDT: number;
         cNGN?: number;
         EXT?: number;
+        ZARP?: number;
+        EURC?: number;
+        XSGD?: number;
+        TRYB?: number;
+        USDR?: number;
     };
     tokenStorageSlots?: {
         USDT?: {
@@ -942,6 +947,30 @@ interface ChainConfigData {
             balanceSlot: number;
             allowanceSlot: number;
         };
+        cNGN?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        ZARP?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        EURC?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        XSGD?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        TRYB?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        USDR?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
     };
     addresses: {
         IntentGateway?: `0x${string}`;
@@ -1442,16 +1471,37 @@ declare class IntentsCoprocessor {
     /**
      * Signs and sends an extrinsic. Submissions are serialised through {@link submissionQueue} so
      * concurrent calls never collide on the substrate account nonce — each extrinsic reaches a block
-     * before the next is signed.
+     * (or is confirmed still pooled and returned as `pending`) before the next is signed; auto-nonce
+     * via `system.accountNextIndex` counts pooled extrinsics, so a pending one is never re-used.
      */
     private signAndSendExtrinsic;
     /**
      * Signs and sends an extrinsic, handling status updates and errors.
      * Implements retry logic with progressive tip increases for stuck transactions.
+     *
+     * A retry only happens when the previous attempt verifiably went nowhere. Once an attempt's
+     * extrinsic is known to be pooled (`pending`), re-signing the same call would race our own
+     * submission: the copy either bounces off the pool (1014, same nonce below the replacement
+     * priority bump) or — if the original lands first, freeing the nonce — executes as a duplicate
+     * and fails on-chain (e.g. `BidNotFound` for a retraction). Neither can succeed, so the pending
+     * result is returned for the caller to confirm later.
      */
     private sendExtrinsicWithRetries;
     /**
-     * Sends an extrinsic with a timeout
+     * Classifies a submission rejection. Codes 1013 ("already imported") and 1014 ("priority is
+     * too low") both mean a copy of this account+nonce is already in the pool — almost always our
+     * own earlier attempt whose watch handle didn't confirm cleanly. That extrinsic is in flight;
+     * resubmitting can only bounce again or land a duplicate, so these are surfaced as `pending`
+     * rather than failure.
+     */
+    private classifySubmissionError;
+    /**
+     * Sends an extrinsic with a timeout.
+     *
+     * A timeout is only a failure when the extrinsic never made it into the transaction pool.
+     * Once a pool-entry status (Future/Ready/Broadcast/Retracted) has been seen, the extrinsic is
+     * in flight and may well execute after the watch is abandoned — the result is then `pending`,
+     * telling the caller to confirm the outcome later instead of re-signing the same call.
      */
     private sendWithTimeout;
     /**
@@ -2948,6 +2998,15 @@ interface BidSubmissionResult {
      * Error message if submission failed
      */
     error?: string;
+    /**
+     * The extrinsic is (or may still be) in the transaction pool: it was accepted but its
+     * inclusion was not observed before the watch timed out, or a resubmission bounced off an
+     * earlier copy already pooled (RPC 1013/1014). Only meaningful when `success` is false —
+     * the operation is in flight, not failed, and must not be re-signed with the same nonce.
+     * Callers should confirm the outcome later (e.g. re-check on-chain state) instead of
+     * treating this as a terminal failure.
+     */
+    pending?: boolean;
 }
 /**
  * Represents a storage entry from pallet-intents Bids storage
@@ -4638,10 +4697,14 @@ interface LpBalance {
     tokenAddress: HexString;
     balance: bigint;
 }
-/** One verified solver behind a leg's quote. */
+/** One verified solver behind a leg's quote, holding inventory to deliver it. */
 interface PhantomLegBidder {
     solver: HexString;
-    /** The solver's output-token inventory on the destination chain — its weight in the median. */
+    /**
+     * The solver's output-token inventory on the destination chain — its weight in the median.
+     * Always greater than zero: a solver quoting a leg it holds none of is dropped, not recorded
+     * at zero, since it can deliver nothing at any price.
+     */
     weight: bigint;
     /**
      * Source chains the solver's signed paymasterAndData declaration accepts payment from. Null
@@ -4658,13 +4721,18 @@ interface PhantomLegAggregation {
     lowestPrice: bigint;
     highestPrice: bigint;
     medianPrice: bigint;
+    /** Backed quotes behind the price. Quotes from solvers holding no inventory are not counted. */
     bidCount: number;
-    /** The verified solvers quoting this leg; bidCount === bidders.length. */
+    /** The verified, inventory-backed solvers quoting this leg; bidCount === bidders.length. */
     bidders: PhantomLegBidder[];
 }
 /** The aggregated result for a single phantom order's bid window. */
 interface PhantomAggregation {
-    /** One entry per leg that at least one solver quoted; legs nobody quoted are absent. */
+    /**
+     * One entry per leg that at least one solver quoted AND at least one of those quotes is backed
+     * by output-token inventory on the destination chain. Legs nobody quoted are absent, and so are
+     * legs every bidder quoted on zero inventory — neither is a price anyone could trade against.
+     */
     legs: PhantomLegAggregation[];
     lpBalances: LpBalance[];
 }

package/dist/node/intents-helpers.cjs

@@ -2651,17 +2651,28 @@ async function aggregatePhantomBids(params) {
     }
   }
   if (quotesByLeg.size === 0) return null;
-  const legs = [...quotesByLeg.entries()].sort(([a], [b]) => a - b).map(([legIndex, { outputToken, quotes, bidders }]) => {
-    const medianPrice = weightedMedian(quotes);
-    return {
-      legIndex,
-      outputToken,
-      lowestPrice: medianPrice,
-      highestPrice: medianPrice,
-      medianPrice,
-      bidCount: quotes.length,
-      bidders
-    };
+  const legs = [...quotesByLeg.entries()].sort(([a], [b]) => a - b).flatMap(([legIndex, { outputToken, quotes, bidders }]) => {
+    const backedQuotes = quotes.filter((quote) => quote.weight > 0n);
+    const backedBidders = bidders.filter((bidder) => bidder.weight > 0n);
+    if (backedQuotes.length === 0) {
+      logger?.warn(
+        { commitment, chain, legIndex, outputToken, quotes: quotes.length },
+        "Dropping phantom leg: no bidder holds the output token on this chain, so no quote is backed"
+      );
+      return [];
+    }
+    const medianPrice = weightedMedian(backedQuotes);
+    return [
+      {
+        legIndex,
+        outputToken,
+        lowestPrice: medianPrice,
+        highestPrice: medianPrice,
+        medianPrice,
+        bidCount: backedQuotes.length,
+        bidders: backedBidders
+      }
+    ];
   });
   return { legs, lpBalances };
 }