@hyperbridge/sdk 2.7.2 → 2.8.2

package/dist/node/index.cjs

@@ -2699,13 +2699,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",
@@ -2885,13 +2898,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",
@@ -2952,13 +2974,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",
@@ -3259,8 +3289,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,
@@ -4852,6 +4883,24 @@ var ABI3 = [
             internalType: "uint256"
           }
         ]
+      },
+      {
+        name: "predispatchCall",
+        type: "bytes",
+        indexed: false,
+        internalType: "bytes"
+      },
+      {
+        name: "outputCall",
+        type: "bytes",
+        indexed: false,
+        internalType: "bytes"
+      },
+      {
+        name: "graffiti",
+        type: "bytes32",
+        indexed: false,
+        internalType: "bytes32"
       }
     ],
     anonymous: false
@@ -7899,15 +7948,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();
@@ -7918,7 +7977,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) {
@@ -7934,12 +7993,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;
@@ -7948,12 +8025,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);
@@ -8011,7 +8093,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
         if (!resolved) {
           resolved = true;
           clearTimeout(timeoutId);
-          resolve({ success: false, error: err.message });
+          resolve(this.classifySubmissionError(err));
         }
       });
     });
@@ -8185,9 +8267,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] = viem.decodeAbiParameters([orderType], rawHex);
@@ -8233,14 +8313,17 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
     const orders = [];
     for (const { event } of records) {
       if (event.section !== "intentsCoprocessor" || event.method !== "PhantomOrderRegistered") continue;
-      const [commitment, chain, createdAt, tokenA, tokenB, standardAmount] = event.data;
+      const [commitment, chain, createdAt, legs] = event.data;
       orders.push({
         commitment: commitment.toHex(),
         chain: new TextDecoder().decode(util.hexToU8a(chain.toHex())),
         createdAt: createdAt.toNumber(),
-        tokenA: tokenA.toHex(),
-        tokenB: tokenB.toHex(),
-        standardAmount: BigInt(standardAmount.toString())
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        legs: legs.map((leg) => ({
+          tokenA: leg.tokenA.toHex(),
+          tokenB: leg.tokenB.toHex(),
+          standardAmount: BigInt(leg.standardAmount.toString())
+        }))
       });
     }
     return orders;
@@ -15536,13 +15619,13 @@ function deriveCanonicalPlacedOrder(order, args) {
     session: args.session,
     predispatch: {
       assets: args.predispatch.map((asset) => ({ ...asset })),
-      call: order.predispatch.call
+      call: args.predispatchCall ?? order.predispatch.call
     },
     inputs: args.inputs.map((asset) => ({ ...asset })),
     output: {
       beneficiary: args.beneficiary,
       assets: args.outputs.map((asset) => ({ ...asset })),
-      call: order.output.call
+      call: args.outputCall ?? order.output.call
     }
   };
   return { ...canonicalOrder, id: orderCommitment(canonicalOrder) };
@@ -16973,14 +17056,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;
@@ -16997,22 +17080,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.
@@ -17352,6 +17447,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
@@ -17385,8 +17484,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`.
@@ -17421,14 +17522,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,
@@ -17436,7 +17537,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).
@@ -17577,20 +17678,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;
@@ -19120,6 +19210,44 @@ var IntentGateway = class _IntentGateway {
     }
   }
 };
+var FILL_ORDER_ABI = IntentGatewayV2_default.ABI;
+var DECLARATION_VERSION = 1;
+var MAX_DECLARED_CHAINS = 255;
+function encodeAcceptedSourceChains(chains2) {
+  if (chains2.length > MAX_DECLARED_CHAINS) {
+    throw new Error(`Cannot declare more than ${MAX_DECLARED_CHAINS} source chains`);
+  }
+  const bytes = [DECLARATION_VERSION, chains2.length];
+  for (const chain of chains2) {
+    const encoded = util.stringToU8a(chain);
+    if (encoded.length === 0 || encoded.length > 255) {
+      throw new Error(`Invalid state machine id in source chain declaration: ${chain}`);
+    }
+    bytes.push(encoded.length, ...encoded);
+  }
+  return util.u8aToHex(new Uint8Array(bytes));
+}
+function decodeAcceptedSourceChains(paymasterAndData) {
+  if (!paymasterAndData || !util.isHex(paymasterAndData)) return null;
+  const bytes = util.hexToU8a(paymasterAndData);
+  if (bytes.length < 2 || bytes[0] !== DECLARATION_VERSION) return null;
+  const count = bytes[1];
+  const chains2 = [];
+  let offset = 2;
+  for (let entry = 0; entry < count; entry++) {
+    if (offset >= bytes.length) return null;
+    const length = bytes[offset];
+    offset += 1;
+    if (length === 0 || offset + length > bytes.length) return null;
+    chains2.push(util.u8aToString(bytes.subarray(offset, offset + length)));
+    offset += length;
+  }
+  if (offset !== bytes.length) return null;
+  return chains2;
+}
+FILL_ORDER_ABI.find(
+  (item) => item?.type === "function" && item?.name === "fillOrder"
+)?.inputs?.[0];
 var TokenGateway = class {
   source;
   dest;
@@ -23659,8 +23787,10 @@ exports.convertStateMachineEnumToString = convertStateMachineEnumToString;
 exports.convertStateMachineIdToEnum = convertStateMachineIdToEnum;
 exports.createEvmChain = createEvmChain;
 exports.createQueryClient = createQueryClient;
+exports.decodeAcceptedSourceChains = decodeAcceptedSourceChains;
 exports.decodeERC7821ExecuteBatch = decodeERC7821ExecuteBatch;
 exports.decodeUserOpScale = decodeUserOpScale;
+exports.encodeAcceptedSourceChains = encodeAcceptedSourceChains;
 exports.encodeERC7821ExecuteBatch = encodeERC7821ExecuteBatch;
 exports.encodeISMPMessage = encodeISMPMessage;
 exports.encodeStateMachineId = encodeStateMachineId;