@hyperbridge/sdk 2.8.0 → 2.8.2

package/dist/browser/index.d.ts

@@ -929,6 +929,11 @@ interface ChainConfigData {
         USDT: number;
         cNGN?: number;
         EXT?: number;
+        ZARP?: number;
+        EURC?: number;
+        XSGD?: number;
+        TRYB?: number;
+        USDR?: number;
     };
     tokenStorageSlots?: {
         USDT?: {
@@ -947,6 +952,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}`;
@@ -1987,16 +2016,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;
     /**
@@ -3706,6 +3756,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

package/dist/browser/index.js

@@ -2738,13 +2738,26 @@ var chainConfigs = {
     tokenDecimals: {
       USDC: 6,
       USDT: 6,
-      cNGN: 6
+      cNGN: 6,
+      ZARP: 18,
+      EURC: 6,
+      XSGD: 6,
+      TRYB: 6,
+      USDR: 6
     },
     tokenStorageSlots: {
       USDT: { balanceSlot: 2, allowanceSlot: 5 },
       USDC: { balanceSlot: 9, allowanceSlot: 10 },
       WETH: { balanceSlot: 3, allowanceSlot: 4 },
-      DAI: { balanceSlot: 0, allowanceSlot: 0 }
+      DAI: { balanceSlot: 0, allowanceSlot: 0 },
+      cNGN: { balanceSlot: 201, allowanceSlot: 202 },
+      // custom upgradeable layout
+      ZARP: { balanceSlot: 51, allowanceSlot: 52 },
+      EURC: { balanceSlot: 9, allowanceSlot: 10 },
+      // Circle FiatToken layout
+      XSGD: { balanceSlot: 7, allowanceSlot: 8 },
+      TRYB: { balanceSlot: 9, allowanceSlot: 10 },
+      USDR: { balanceSlot: 51, allowanceSlot: 52 }
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
@@ -2924,13 +2937,22 @@ var chainConfigs = {
       USDC: 6,
       USDT: 6,
       cNGN: 6,
-      EXT: 18
+      EXT: 18,
+      ZARP: 18,
+      EURC: 6,
+      USDR: 6
     },
     tokenStorageSlots: {
       USDT: { balanceSlot: 0, allowanceSlot: 1 },
       USDC: { balanceSlot: 9, allowanceSlot: 10 },
       WETH: { balanceSlot: 3, allowanceSlot: 4 },
-      DAI: { balanceSlot: 0, allowanceSlot: 0 }
+      DAI: { balanceSlot: 0, allowanceSlot: 0 },
+      cNGN: { balanceSlot: 201, allowanceSlot: 202 },
+      // custom upgradeable layout
+      ZARP: { balanceSlot: 51, allowanceSlot: 52 },
+      EURC: { balanceSlot: 9, allowanceSlot: 10 },
+      // Circle FiatToken layout
+      USDR: { balanceSlot: 51, allowanceSlot: 52 }
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
@@ -2991,13 +3013,21 @@ var chainConfigs = {
       USDC: 6,
       USDT: 6,
       EXT: 18,
-      cNGN: 6
+      cNGN: 6,
+      ZARP: 18,
+      XSGD: 6,
+      USDR: 6
     },
     tokenStorageSlots: {
       USDT: { balanceSlot: 0, allowanceSlot: 1 },
       USDC: { balanceSlot: 9, allowanceSlot: 10 },
       WETH: { balanceSlot: 3, allowanceSlot: 4 },
-      DAI: { balanceSlot: 0, allowanceSlot: 0 }
+      DAI: { balanceSlot: 0, allowanceSlot: 0 },
+      cNGN: { balanceSlot: 201, allowanceSlot: 202 },
+      // custom upgradeable layout
+      ZARP: { balanceSlot: 51, allowanceSlot: 52 },
+      XSGD: { balanceSlot: 7, allowanceSlot: 8 },
+      USDR: { balanceSlot: 51, allowanceSlot: 52 }
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
@@ -3298,8 +3328,9 @@ var chainConfigs = {
     assets: {
       WETH: "0x0000000000000000000000000000000000000000",
       DAI: "0x0000000000000000000000000000000000000000",
+      // Asset Hub assets at their asset-id precompile addresses: 0x539 = 1337, 0x7c0 = 1984.
       USDC: "0x0000053900000000000000000000000001200000",
-      USDT: "0x0000000000000000000000000000000000000000"
+      USDT: "0x000007c000000000000000000000000001200000"
     },
     tokenDecimals: {
       USDC: 6,
@@ -7956,15 +7987,25 @@ var IntentsCoprocessor = 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.
    */
   async signAndSendExtrinsic(extrinsic, maxRetries = 3, timeoutMs = 3e4) {
-    const result = await this.submissionQueue.add(() => this.sendExtrinsicWithRetries(extrinsic, maxRetries, timeoutMs));
+    const result = await this.submissionQueue.add(
+      () => this.sendExtrinsicWithRetries(extrinsic, maxRetries, timeoutMs)
+    );
     return result ?? { success: false, error: "Submission queue returned no result" };
   }
   /**
    * 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.
    */
   async sendExtrinsicWithRetries(extrinsic, maxRetries, timeoutMs) {
     const keyPair = this.getKeyPair();
@@ -7975,7 +8016,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
       attempt++;
       try {
         const result = await this.sendWithTimeout(extrinsic, keyPair, currentTip, timeoutMs);
-        if (result.success || result.error?.includes("Dispatch error")) {
+        if (result.success || result.pending || result.error?.includes("Dispatch error")) {
           return result;
         }
       } catch (err) {
@@ -7991,12 +8032,30 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
     };
   }
   /**
-   * 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.
+   */
+  classifySubmissionError(err) {
+    const code = err.code;
+    const inFlight = code === 1013 || code === 1014 || /already imported|already in the pool|priority is too low/i.test(err.message);
+    return { success: false, pending: inFlight || void 0, error: err.message };
+  }
+  /**
+   * 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.
    */
   async sendWithTimeout(extrinsic, keyPair, tip, timeoutMs) {
     return new Promise((resolve) => {
       let resolved = false;
       let unsubscribe = null;
+      let enteredPool = false;
       const timeoutId = setTimeout(() => {
         if (!resolved) {
           resolved = true;
@@ -8005,12 +8064,17 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
           }
           resolve({
             success: false,
-            error: `Transaction timed out after ${timeoutMs}ms`
+            pending: enteredPool || void 0,
+            extrinsicHash: enteredPool ? extrinsic.hash.toHex() : void 0,
+            error: `Transaction timed out after ${timeoutMs}ms${enteredPool ? " while in the transaction pool" : ""}`
           });
         }
       }, timeoutMs);
       extrinsic.signAndSend(keyPair, { tip }, (result) => {
         if (resolved) return;
+        if (result.status.isFuture || result.status.isReady || result.status.isBroadcast || result.status.isRetracted) {
+          enteredPool = true;
+        }
         if (result.dispatchError && (result.status.isInBlock || result.status.isFinalized)) {
           resolved = true;
           clearTimeout(timeoutId);
@@ -8068,7 +8132,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
         if (!resolved) {
           resolved = true;
           clearTimeout(timeoutId);
-          resolve({ success: false, error: err.message });
+          resolve(this.classifySubmissionError(err));
         }
       });
     });
@@ -8242,9 +8306,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
     if (!result || result.isNone) return null;
     const rawHex = result.unwrap().toHex();
     if (rawHex === "0x" || rawHex === "0x00") return null;
-    const placeOrderAbi = IntentGatewayV2_default.ABI.find(
-      (item) => item.type === "function" && item.name === "placeOrder"
-    );
+    const placeOrderAbi = IntentGatewayV2_default.ABI.find((item) => item.type === "function" && item.name === "placeOrder");
     const orderType = placeOrderAbi?.inputs?.[0];
     if (!orderType) return null;
     const [decoded] = decodeAbiParameters([orderType], rawHex);
@@ -17043,14 +17105,14 @@ var BidManager = class {
   }
   /**
    * Autopilot bid selection: sorts the given bids by output value, simulates
-   * each in order until one passes, then executes that bid. For consumers that
-   * do not need custom selection logic.
+   * each in order and attempts execution. Any bid that fails simulation or
+   * execution is skipped once so the next ranked bid can be attempted in the
+   * same round. For consumers that do not need custom selection logic.
    *
    * @param order - The placed order to fill.
    * @param bids - Candidate bids (from {@link buildBids}).
    * @returns A {@link SelectBidResult} for the executed bid.
-   * @throws If no valid bids exist, all simulations fail, or the bundler rejects
-   *   the UserOperation.
+   * @throws If no valid bids exist or every bid fails simulation/execution.
    */
   async selectAndExecuteBest(order, bids) {
     const commitment = order.id;
@@ -17067,22 +17129,34 @@ var BidManager = class {
       throw new Error("No valid bids found");
     }
     console.log(`[BidManager] Simulating ${sortedBids.length} sorted bid(s) to find a valid one`);
+    let simulationFailures = 0;
+    let executionFailures = 0;
     for (let idx = 0; idx < sortedBids.length; idx++) {
       const bid = sortedBids[idx];
       console.log(`[BidManager] Simulating bid ${idx + 1}/${sortedBids.length} from solver=${bid.solverAddress}`);
       try {
         await bid.simulate();
       } catch (err) {
+        simulationFailures += 1;
         console.warn(
           `[BidManager] Bid ${idx + 1} from solver=${bid.solverAddress}: simulation FAILED: ${err instanceof Error ? err.message : String(err)}`
         );
         continue;
       }
       console.log(`[BidManager] Bid ${idx + 1} from solver=${bid.solverAddress}: simulation PASSED`);
-      return bid.execute();
+      try {
+        return await bid.execute();
+      } catch (err) {
+        executionFailures += 1;
+        console.warn(
+          `[BidManager] Bid ${idx + 1} from solver=${bid.solverAddress}: execution FAILED: ${err instanceof Error ? err.message : String(err)}; trying next bid`
+        );
+      }
     }
-    console.error(`[BidManager] All ${sortedBids.length} bid(s) failed simulation for commitment=${commitment}`);
-    throw new Error("No bids passed simulation");
+    console.error(
+      `[BidManager] No executable bids for commitment=${commitment}: ${simulationFailures} simulation failure(s), ${executionFailures} execution failure(s)`
+    );
+    throw new Error("No bids passed simulation and execution");
   }
   /**
    * Sorts a list of bids for the given order by output value.
@@ -17422,6 +17496,10 @@ var BidManager = class {
   }
 };
 var RELAYER_MESSAGE_GAS = 1000000n;
+var NO_BUNDLER_FILL_GAS_BASE = 700000n;
+var NO_BUNDLER_FILL_GAS_PER_OUTPUT = 150000n;
+var NO_BUNDLER_PAYMASTER_VERIFICATION_GAS = 250000n;
+var NO_BUNDLER_PAYMASTER_POST_OP_GAS = 100000n;
 var GasEstimator = class {
   /**
    * @param ctx - Shared IntentsV2 context providing the source and destination
@@ -17455,8 +17533,10 @@ var GasEstimator = class {
    * headroom. If the bundler is Pimlico, gas prices are refined with
    * `pimlico_getUserOperationGasPrice`.
    *
-   * **Fallback path (no bundler):** calls `estimateContractGas` directly on
-   * `fillOrder` with state overrides.
+   * **Fallback path (no bundler):** uses a fixed budget
+   * ({@link NO_BUNDLER_FILL_GAS_BASE} plus {@link NO_BUNDLER_FILL_GAS_PER_OUTPUT}
+   * per output leg) — public RPCs don't reliably support estimation with
+   * state overrides.
    *
    * @param params - Parameters including the order to estimate and optional
    *   percentage bumps for `maxPriorityFeePerGas` and `maxFeePerGas`.
@@ -17491,14 +17571,14 @@ var GasEstimator = class {
     }
     const isSameChain = souceStateMachineId === destStateMachineId;
     const [stateOverridesResult, crossChainFees] = await Promise.all([
-      this.buildStateOverride({
+      this.ctx.bundlerUrl ? this.buildStateOverride({
         accountAddress: solverAccountAddress,
         chain: destStateMachineId,
         outputAssets: assetsForOverrides,
         spenderAddress: intentGatewayV2Address,
         intentGatewayV2Address,
         entryPointAddress
-      }),
+      }) : Promise.resolve({ viem: [], bundler: {} }),
       isSameChain ? Promise.resolve({ postRequestFee: 0n, relayerFeeInSourceFeeToken: 0n }) : this.estimateCrossChainFees(
         sourceFeeToken,
         destFeeToken,
@@ -17506,7 +17586,7 @@ var GasEstimator = class {
         orderFeeGasPriceBumpPercent
       )
     ]);
-    const { viem: stateOverrides, bundler: bundlerStateOverrides } = stateOverridesResult;
+    const { bundler: bundlerStateOverrides } = stateOverridesResult;
     const fillOptions = {
       relayerFee: crossChainFees.postRequestFee,
       // Always dispatch with the fee token (see the method docs).
@@ -17647,20 +17727,9 @@ var GasEstimator = class {
         console.warn("Bundler gas estimation failed, using fallback values:", e);
       }
     } else {
-      try {
-        const estimatedGas = await this.ctx.dest.client.estimateContractGas({
-          abi: ABI3,
-          address: intentGatewayV2Address,
-          functionName: "fillOrder",
-          args: [transformOrderForContract(order), fillOptions],
-          account: solverAccountAddress,
-          value: totalNativeValue,
-          stateOverride: stateOverrides
-        });
-        callGasLimit = estimatedGas * 105n / 100n;
-      } catch (e) {
-        console.warn("fillOrder gas estimation failed, using fallback:", e);
-      }
+      callGasLimit = NO_BUNDLER_FILL_GAS_BASE + NO_BUNDLER_FILL_GAS_PER_OUTPUT * BigInt(order.output.assets.length);
+      paymasterVerificationGasLimit = NO_BUNDLER_PAYMASTER_VERIFICATION_GAS;
+      paymasterPostOpGasLimit = NO_BUNDLER_PAYMASTER_POST_OP_GAS;
     }
     const totalGas = callGasLimit + verificationGasLimit + preVerificationGas + paymasterVerificationGasLimit + paymasterPostOpGasLimit;
     const rawTotalGasCostWei = totalGas * maxFeePerGas;