@defuse-protocol/intents-sdk 0.17.1 → 0.19.0

package/dist/index.js

@@ -1,11 +1,11 @@
 // src/sdk.ts
 import {
-  assert as assert11,
+  assert as assert13,
   PUBLIC_NEAR_RPC_URLS,
-  RETRY_CONFIGS as RETRY_CONFIGS2,
-  configsByEnvironment as configsByEnvironment6,
+  RETRY_CONFIGS as RETRY_CONFIGS3,
+  configsByEnvironment as configsByEnvironment7,
   nearFailoverRpcProvider,
-  solverRelay as solverRelay3
+  solverRelay as solverRelay4
 } from "@defuse-protocol/internal-utils";
 import hotOmniSdk from "@hot-labs/omni-sdk";
 import { stringify } from "viem";
@@ -910,19 +910,452 @@ var IntentsBridge = class {
   }
 };
 
-// src/bridges/poa-bridge/poa-bridge.ts
+// src/bridges/omni-bridge/omni-bridge.ts
 import {
-  assert as assert8,
+  assert as assert9,
+  RETRY_CONFIGS as RETRY_CONFIGS2,
   configsByEnvironment as configsByEnvironment3,
-  poaBridge,
-  utils as utils8
+  getNearNep141MinStorageBalance as getNearNep141MinStorageBalance3,
+  getNearNep141StorageBalance as getNearNep141StorageBalance3,
+  solverRelay as solverRelay2
 } from "@defuse-protocol/internal-utils";
 import TTLCache from "@isaacs/ttlcache";
+import { retry as retry2 } from "@lifeomic/attempt";
+import {
+  ChainKind as ChainKind2,
+  OmniBridgeAPI,
+  getBridgedToken,
+  getChain,
+  isEvmChain,
+  omniAddress as omniAddress2,
+  parseOriginChain
+} from "omni-bridge-sdk";
 
-// src/bridges/poa-bridge/poa-bridge-utils.ts
-import { utils as utils7 } from "@defuse-protocol/internal-utils";
+// src/bridges/omni-bridge/error.ts
+import { BaseError as BaseError3 } from "@defuse-protocol/internal-utils";
+var OmniTransferNotFoundError = class extends BaseError3 {
+  constructor(txHash) {
+    super("Omni transfer with given hash is not found in the relayer.", {
+      metaMessages: [`OriginTxHash: ${txHash}`],
+      name: "OmniTransferNotFoundError"
+    });
+    this.txHash = txHash;
+  }
+};
+var OmniTransferDestinationChainHashNotFoundError = class extends BaseError3 {
+  constructor(txHash, destinationChain) {
+    super("Relayer did not return destination chain hash for a transfer.", {
+      metaMessages: [
+        `OriginTxHash: ${txHash}`,
+        `DestinationChain: ${destinationChain}`
+      ],
+      name: "OmniTransferDestinationChainHashNotFoundError"
+    });
+    this.txHash = txHash;
+    this.destinationChain = destinationChain;
+  }
+};
+var TokenNotFoundInDestinationChainError = class extends BaseError3 {
+  constructor(token, destinationChain) {
+    super(
+      `The token ${token} doesn't exist in destination chain ${destinationChain}`,
+      {
+        metaMessages: [
+          `Token: ${token}`,
+          `Destination Chain: ${destinationChain}`
+        ],
+        name: "TokenNotFoundInDestinationChainError"
+      }
+    );
+    this.token = token;
+    this.destinationChain = destinationChain;
+  }
+};
+var TokenNotSupportedByOmniRelayerError = class extends BaseError3 {
+  constructor(token) {
+    super(`Omni Relayer doesn't accept fee in the transferred token ${token}`, {
+      metaMessages: [`Token: ${token}`],
+      name: "TokenNotSupportedByOmniRelayerError"
+    });
+    this.token = token;
+  }
+};
+
+// src/bridges/omni-bridge/omni-bridge-constants.ts
+var NEAR_NATIVE_ASSET_ID3 = "nep141:wrap.near";
+var OMNI_BRIDGE_CONTRACT = "omni.bridge.near";
+
+// src/bridges/omni-bridge/omni-bridge-utils.ts
+import { assert as assert8, utils as utils7 } from "@defuse-protocol/internal-utils";
+import { ChainKind, omniAddress } from "omni-bridge-sdk";
 function createWithdrawIntentPrimitive3(params) {
-  const { contractId: tokenAccountId } = utils7.parseDefuseAssetId(
+  const { contractId: tokenAccountId, standard } = utils7.parseDefuseAssetId(
+    params.assetId
+  );
+  assert8(standard === "nep141", "Only NEP-141 is supported");
+  return {
+    intent: "ft_withdraw",
+    token: tokenAccountId,
+    receiver_id: OMNI_BRIDGE_CONTRACT,
+    amount: params.amount.toString(),
+    storage_deposit: params.storageDeposit > 0n ? params.storageDeposit.toString() : null,
+    msg: JSON.stringify({
+      recipient: omniAddress(params.omniChainKind, params.destinationAddress),
+      fee: params.transferredTokenFee.toString(),
+      native_token_fee: "0"
+    })
+  };
+}
+function caip2ToChainKind(network) {
+  switch (network) {
+    case Chains.Ethereum:
+      return ChainKind.Eth;
+    case Chains.Base:
+      return ChainKind.Base;
+    case Chains.Arbitrum:
+      return ChainKind.Arb;
+    case Chains.Solana:
+      return ChainKind.Sol;
+    // case Chains.Bitcoin:
+    // 	return ChainKind.Btc;
+    default:
+      return null;
+  }
+}
+function chainKindToCaip2(network) {
+  switch (network) {
+    case ChainKind.Eth:
+      return Chains.Ethereum;
+    case ChainKind.Base:
+      return Chains.Base;
+    case ChainKind.Arb:
+      return Chains.Arbitrum;
+    case ChainKind.Sol:
+      return Chains.Solana;
+    // case ChainKind.Btc:
+    // 	return Chains.Bitcoin;
+    default:
+      return null;
+  }
+}
+var CHAIN_PATTERNS = {
+  "nbtc.bridge.near": ChainKind.Btc,
+  "eth.bridge.near": ChainKind.Eth,
+  "sol.omdep.near": ChainKind.Sol,
+  "base.omdep.near": ChainKind.Base,
+  "arb.omdep.near": ChainKind.Arb
+};
+function validateOmniToken(nearAddress) {
+  return nearAddress in CHAIN_PATTERNS || /\.(omdep\.near|factory\.bridge\.near)$/.test(nearAddress);
+}
+
+// src/bridges/omni-bridge/omni-bridge.ts
+var OmniBridge = class {
+  // 10800000 - 3 hours
+  constructor({
+    env,
+    nearProvider
+  }) {
+    this.storageDepositCache = new TTLCache({ ttl: 108e5 });
+    // 10800000 - 3 hours
+    this.destinationChainAddressCache = new TTLCache({ ttl: 108e5 });
+    this.env = env;
+    this.nearProvider = nearProvider;
+    this.omniBridgeAPI = new OmniBridgeAPI();
+  }
+  is(routeConfig) {
+    return routeConfig.route === RouteEnum.OmniBridge;
+  }
+  async supports(params) {
+    if (params.routeConfig && !this.is(params.routeConfig)) {
+      return false;
+    }
+    const parsed = parseDefuseAssetId(params.assetId);
+    const omniBridgeSetWithNoChain = Boolean(
+      params.routeConfig && params.routeConfig.route === RouteEnum.OmniBridge && params.routeConfig.chain === void 0
+    );
+    const targetChainSpecified = this.targetChainSpecified(params.routeConfig);
+    const nonValidStandard = parsed.standard !== "nep141";
+    if (nonValidStandard && (omniBridgeSetWithNoChain || targetChainSpecified)) {
+      throw new UnsupportedAssetIdError(
+        params.assetId,
+        `Only NEP-141 tokens are supported by Omni Bridge.`
+      );
+    }
+    if (nonValidStandard) return false;
+    const nonValidToken = validateOmniToken(parsed.contractId) === false;
+    if (nonValidToken && omniBridgeSetWithNoChain) {
+      throw new UnsupportedAssetIdError(
+        params.assetId,
+        `Non valid omni contract id ${parsed.contractId}`
+      );
+    }
+    if (!targetChainSpecified && nonValidToken) return false;
+    let omniChainKind = null;
+    let caip2Chain = null;
+    if (this.targetChainSpecified(params.routeConfig)) {
+      omniChainKind = caip2ToChainKind(params.routeConfig.chain);
+      if (omniChainKind === null) {
+        throw new UnsupportedAssetIdError(
+          params.assetId,
+          `Chain ${params.routeConfig.chain} is not supported in Omni Bridge.`
+        );
+      }
+      caip2Chain = params.routeConfig.chain;
+    } else {
+      omniChainKind = parseOriginChain(parsed.contractId);
+      if (omniChainKind === null) {
+        throw new UnsupportedAssetIdError(
+          params.assetId,
+          `Withdrawal of ${parsed.contractId} to its origin chain is not supported in Omni Bridge.`
+        );
+      }
+      caip2Chain = chainKindToCaip2(omniChainKind);
+      if (caip2Chain === null) {
+        throw new UnsupportedAssetIdError(
+          params.assetId,
+          `Withdrawal of ${parsed.contractId} to its origin chain is not supported in Omni Bridge.`
+        );
+      }
+    }
+    const tokenOnDestinationNetwork = await this.getCachedDestinationTokenAddress(
+      parsed.contractId,
+      omniChainKind
+    );
+    if (tokenOnDestinationNetwork === null) {
+      throw new TokenNotFoundInDestinationChainError(
+        params.assetId,
+        caip2Chain
+      );
+    }
+    return true;
+  }
+  targetChainSpecified(routeConfig) {
+    return Boolean(
+      routeConfig?.route && routeConfig.route === RouteEnum.OmniBridge && routeConfig.chain
+    );
+  }
+  parseAssetId(assetId) {
+    const parsed = parseDefuseAssetId(assetId);
+    if (parsed.standard !== "nep141") return null;
+    const omniChainKind = parseOriginChain(parsed.contractId);
+    if (omniChainKind === null) return null;
+    const blockchain = chainKindToCaip2(omniChainKind);
+    if (blockchain === null) return null;
+    return Object.assign(parsed, {
+      blockchain,
+      bridgeName: BridgeNameEnum.Omni,
+      address: parsed.contractId
+    });
+  }
+  makeAssetInfo(assetId, routeConfig) {
+    const parsed = parseDefuseAssetId(assetId);
+    if (parsed.standard !== "nep141") return null;
+    let omniChainKind = null;
+    let blockchain = null;
+    if (this.targetChainSpecified(routeConfig)) {
+      omniChainKind = caip2ToChainKind(routeConfig.chain);
+      blockchain = routeConfig.chain;
+    } else {
+      omniChainKind = parseOriginChain(parsed.contractId);
+      if (omniChainKind === null) return null;
+      blockchain = chainKindToCaip2(omniChainKind);
+    }
+    if (omniChainKind === null || blockchain === null) return null;
+    return Object.assign(parsed, {
+      blockchain,
+      bridgeName: BridgeNameEnum.Omni,
+      address: parsed.contractId
+    });
+  }
+  async createWithdrawalIntents(args) {
+    const assetInfo = this.makeAssetInfo(
+      args.withdrawalParams.assetId,
+      args.withdrawalParams.routeConfig
+    );
+    assert9(
+      assetInfo !== null,
+      `Asset ${args.withdrawalParams.assetId} is not supported by Omni Bridge`
+    );
+    const intents = [];
+    if (args.feeEstimation.quote !== null) {
+      intents.push({
+        intent: "token_diff",
+        diff: {
+          [args.feeEstimation.quote.defuse_asset_identifier_in]: `-${args.feeEstimation.quote.amount_in}`,
+          [args.feeEstimation.quote.defuse_asset_identifier_out]: args.feeEstimation.quote.amount_out
+        },
+        referral: args.referral
+      });
+    }
+    const omniChainKind = caip2ToChainKind(assetInfo.blockchain);
+    assert9(
+      omniChainKind !== null,
+      `Chain ${assetInfo.blockchain} is not supported by Omni Bridge`
+    );
+    const intent = createWithdrawIntentPrimitive3({
+      assetId: args.withdrawalParams.assetId,
+      destinationAddress: args.withdrawalParams.destinationAddress,
+      amount: args.withdrawalParams.amount + args.feeEstimation.amount,
+      omniChainKind,
+      storageDeposit: args.feeEstimation.quote ? BigInt(args.feeEstimation.quote.amount_out) : 0n,
+      transferredTokenFee: args.feeEstimation.amount
+    });
+    intents.push(intent);
+    return Promise.resolve(intents);
+  }
+  async validateWithdrawal(args) {
+    assert9(
+      args.feeEstimation.amount > 0n,
+      `Fee must be greater than zero. Current fee is ${args.feeEstimation.amount}.`
+    );
+    return;
+  }
+  async estimateWithdrawalFee(args) {
+    const assetInfo = this.makeAssetInfo(
+      args.withdrawalParams.assetId,
+      args.withdrawalParams.routeConfig
+    );
+    assert9(
+      assetInfo !== null,
+      `Asset ${args.withdrawalParams.assetId} is not supported by Omni Bridge`
+    );
+    const omniChainKind = caip2ToChainKind(assetInfo.blockchain);
+    assert9(
+      omniChainKind !== null,
+      `Chain ${assetInfo.blockchain} is not supported by Omni Bridge`
+    );
+    const fee = await this.omniBridgeAPI.getFee(
+      omniAddress2(ChainKind2.Near, configsByEnvironment3[this.env].contractID),
+      omniAddress2(omniChainKind, args.withdrawalParams.destinationAddress),
+      omniAddress2(ChainKind2.Near, assetInfo.contractId)
+    );
+    if (fee.transferred_token_fee === null) {
+      throw new TokenNotSupportedByOmniRelayerError(
+        args.withdrawalParams.assetId
+      );
+    }
+    const [minStorageBalance, userStorageBalance] = await this.getCachedStorageDepositValue(assetInfo.contractId);
+    if (minStorageBalance <= userStorageBalance) {
+      return {
+        amount: BigInt(fee.transferred_token_fee),
+        quote: null
+      };
+    }
+    const feeAmount = minStorageBalance - userStorageBalance;
+    const feeQuote = await solverRelay2.getQuote({
+      quoteParams: {
+        defuse_asset_identifier_in: args.withdrawalParams.assetId,
+        defuse_asset_identifier_out: NEAR_NATIVE_ASSET_ID3,
+        exact_amount_out: feeAmount.toString(),
+        wait_ms: args.quoteOptions?.waitMs
+      },
+      config: {
+        baseURL: configsByEnvironment3[this.env].solverRelayBaseURL,
+        logBalanceSufficient: false,
+        logger: args.logger
+      }
+    });
+    return {
+      amount: BigInt(fee.transferred_token_fee) + BigInt(feeQuote.amount_in),
+      quote: feeQuote
+    };
+  }
+  async waitForWithdrawalCompletion(args) {
+    return retry2(
+      async () => {
+        if (args.signal?.aborted) {
+          throw args.signal.reason;
+        }
+        const transfer = (await this.omniBridgeAPI.findOmniTransfers({
+          transaction_id: args.tx.hash,
+          offset: args.index,
+          limit: 1
+        }))[0];
+        if (!transfer) throw new OmniTransferNotFoundError(args.tx.hash);
+        const destinationChain = getChain(
+          transfer.transfer_message.recipient
+        );
+        let txHash = null;
+        if (isEvmChain(destinationChain)) {
+          txHash = transfer.finalised?.EVMLog?.transaction_hash;
+        } else if (destinationChain === ChainKind2.Sol) {
+          txHash = transfer.finalised?.Solana?.signature;
+        } else {
+          return { hash: null };
+        }
+        if (!txHash)
+          throw new OmniTransferDestinationChainHashNotFoundError(
+            args.tx.hash,
+            ChainKind2[destinationChain].toLowerCase()
+          );
+        return { hash: txHash };
+      },
+      {
+        ...args.retryOptions ?? RETRY_CONFIGS2.FIVE_MINS_STEADY,
+        handleError: (err, ctx) => {
+          if (err instanceof OmniTransferNotFoundError || err === args.signal?.reason) {
+            ctx.abort();
+          }
+        }
+      }
+    );
+  }
+  /**
+   * Gets storage deposit for a token to avoid frequent RPC calls.
+   * Cache expires after one day using TTL cache.
+   */
+  async getCachedStorageDepositValue(contractId) {
+    const cached = this.storageDepositCache.get(contractId);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const data = await Promise.all([
+      getNearNep141MinStorageBalance3({
+        contractId,
+        nearProvider: this.nearProvider
+      }),
+      getNearNep141StorageBalance3({
+        contractId,
+        accountId: OMNI_BRIDGE_CONTRACT,
+        nearProvider: this.nearProvider
+      })
+    ]);
+    this.storageDepositCache.set(contractId, data);
+    return data;
+  }
+  /**
+   * Gets cached token address on destination chain.
+   * Cache expires after one day using TTL cache.
+   */
+  async getCachedDestinationTokenAddress(contractId, omniChainKind) {
+    const key = `${omniChainKind}:${contractId}`;
+    const cached = this.destinationChainAddressCache.get(key);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const tokenOnDestinationNetwork = await getBridgedToken(
+      omniAddress2(ChainKind2.Near, contractId),
+      omniChainKind
+    );
+    this.destinationChainAddressCache.set(key, tokenOnDestinationNetwork);
+    return tokenOnDestinationNetwork;
+  }
+};
+
+// src/bridges/poa-bridge/poa-bridge.ts
+import {
+  assert as assert10,
+  configsByEnvironment as configsByEnvironment4,
+  poaBridge,
+  utils as utils9
+} from "@defuse-protocol/internal-utils";
+import TTLCache2 from "@isaacs/ttlcache";
+
+// src/bridges/poa-bridge/poa-bridge-utils.ts
+import { utils as utils8 } from "@defuse-protocol/internal-utils";
+function createWithdrawIntentPrimitive4(params) {
+  const { contractId: tokenAccountId } = utils8.parseDefuseAssetId(
     params.assetId
   );
   return {
@@ -997,7 +1430,7 @@ function contractIdToCaip2(contractId) {
 var PoaBridge = class {
   constructor({ env }) {
     // TTL cache for supported tokens with 30-second TTL
-    this.supportedTokensCache = new TTLCache({ ttl: 30 * 1e3 });
+    this.supportedTokensCache = new TTLCache2({ ttl: 30 * 1e3 });
     this.env = env;
   }
   is(routeConfig) {
@@ -1020,7 +1453,7 @@ var PoaBridge = class {
   parseAssetId(assetId) {
     const parsed = parseDefuseAssetId(assetId);
     const contractIdSatisfies = parsed.contractId.endsWith(
-      `.${configsByEnvironment3[this.env].poaTokenFactoryContractID}`
+      `.${configsByEnvironment4[this.env].poaTokenFactoryContractID}`
     );
     if (!contractIdSatisfies) {
       return null;
@@ -1042,7 +1475,7 @@ var PoaBridge = class {
     });
   }
   createWithdrawalIntents(args) {
-    const intent = createWithdrawIntentPrimitive3({
+    const intent = createWithdrawIntentPrimitive4({
       ...args.withdrawalParams,
       amount: args.withdrawalParams.amount + args.feeEstimation.amount,
       destinationMemo: args.withdrawalParams.destinationMemo
@@ -1057,7 +1490,7 @@ var PoaBridge = class {
    */
   async validateWithdrawal(args) {
     const assetInfo = this.parseAssetId(args.assetId);
-    assert8(assetInfo != null, "Asset is not supported");
+    assert10(assetInfo != null, "Asset is not supported");
     const { tokens: tokens2 } = await this.getCachedSupportedTokens(
       [toPoaNetwork(assetInfo.blockchain)],
       args.logger
@@ -1078,16 +1511,16 @@ var PoaBridge = class {
   }
   async estimateWithdrawalFee(args) {
     const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
-    assert8(assetInfo != null, "Asset is not supported");
+    assert10(assetInfo != null, "Asset is not supported");
     const estimation = await poaBridge.httpClient.getWithdrawalEstimate(
       {
-        token: utils8.getTokenAccountId(args.withdrawalParams.assetId),
+        token: utils9.getTokenAccountId(args.withdrawalParams.assetId),
         address: args.withdrawalParams.destinationAddress,
         // biome-ignore lint/suspicious/noExplicitAny: <explanation>
         chain: toPoaNetwork(assetInfo.blockchain)
       },
       {
-        baseURL: configsByEnvironment3[this.env].poaBridgeBaseURL,
+        baseURL: configsByEnvironment4[this.env].poaBridgeBaseURL,
         logger: args.logger
       }
     );
@@ -1102,7 +1535,7 @@ var PoaBridge = class {
       index: args.index,
       signal: args.signal ?? new AbortController().signal,
       retryOptions: args.retryOptions,
-      baseURL: configsByEnvironment3[this.env].poaBridgeBaseURL,
+      baseURL: configsByEnvironment4[this.env].poaBridgeBaseURL,
       logger: args.logger
     });
     return { hash: withdrawalStatus.destinationTxHash };
@@ -1120,7 +1553,7 @@ var PoaBridge = class {
     const data = await poaBridge.httpClient.getSupportedTokens(
       { chains },
       {
-        baseURL: configsByEnvironment3[this.env].poaBridgeBaseURL,
+        baseURL: configsByEnvironment4[this.env].poaBridgeBaseURL,
         logger
       }
     );
@@ -1143,7 +1576,7 @@ var PUBLIC_STELLAR_RPC_URLS = {
 
 // src/intents/intent-executer-impl/intent-executer.ts
 import {
-  configsByEnvironment as configsByEnvironment4
+  configsByEnvironment as configsByEnvironment5
 } from "@defuse-protocol/internal-utils";
 
 // ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_u64.js
@@ -1465,6 +1898,7 @@ async function computeIntentHashBytes(multiPayload) {
         multiPayload
       );
     case "erc191":
+    case "tip191":
       return computeErc191Hash(
         multiPayload
       );
@@ -1525,7 +1959,7 @@ var IntentExecuter = class {
     relayParams: relayParamsFactory,
     ...intentParams
   }) {
-    const verifyingContract = configsByEnvironment4[this.env].contractID;
+    const verifyingContract = configsByEnvironment5[this.env].contractID;
     let intentPayload = defaultIntentPayloadFactory({
       verifying_contract: verifyingContract,
       ...intentParams
@@ -1576,8 +2010,8 @@ async function mergeIntentPayloads(basePayload, intentPayloadFactory) {
 
 // src/intents/intent-relayer-impl/intent-relayer-public.ts
 import {
-  configsByEnvironment as configsByEnvironment5,
-  solverRelay as solverRelay2
+  configsByEnvironment as configsByEnvironment6,
+  solverRelay as solverRelay3
 } from "@defuse-protocol/internal-utils";
 var IntentRelayerPublic = class {
   constructor({ env }) {
@@ -1600,13 +2034,13 @@ var IntentRelayerPublic = class {
     multiPayloads,
     quoteHashes
   }, ctx = {}) {
-    const a = await solverRelay2.publishIntents(
+    const a = await solverRelay3.publishIntents(
       {
         quote_hashes: quoteHashes,
         signed_datas: multiPayloads
       },
       {
-        baseURL: configsByEnvironment5[this.env].solverRelayBaseURL,
+        baseURL: configsByEnvironment6[this.env].solverRelayBaseURL,
         logger: ctx.logger
       }
     );
@@ -1616,10 +2050,10 @@ var IntentRelayerPublic = class {
     throw a.unwrapErr();
   }
   async waitForSettlement(ticket, ctx = {}) {
-    const result = await solverRelay2.waitForIntentSettlement({
+    const result = await solverRelay3.waitForIntentSettlement({
       intentHash: ticket,
       signal: new AbortController().signal,
-      baseURL: configsByEnvironment5[this.env].solverRelayBaseURL,
+      baseURL: configsByEnvironment6[this.env].solverRelayBaseURL,
       logger: ctx.logger
     });
     return {
@@ -1627,7 +2061,7 @@ var IntentRelayerPublic = class {
         hash: result.txHash,
         // Usually relayer's account id is the verifying contract (`intents.near`),
         // but it is not set in stone and may change in the future.
-        accountId: configsByEnvironment5[this.env].contractID
+        accountId: configsByEnvironment6[this.env].contractID
       }
     };
   }
@@ -1641,14 +2075,14 @@ var noopIntentSigner = {
 };
 
 // src/lib/array.ts
-import { assert as assert9 } from "@defuse-protocol/internal-utils";
+import { assert as assert11 } from "@defuse-protocol/internal-utils";
 function zip(arr1, arr2) {
-  assert9(arr1.length === arr2.length, "Arrays must have the same length");
+  assert11(arr1.length === arr2.length, "Arrays must have the same length");
   return arr1.map((v, i) => [v, arr2[i]]);
 }
 
 // src/lib/configure-rpc-config.ts
-import { assert as assert10 } from "@defuse-protocol/internal-utils";
+import { assert as assert12 } from "@defuse-protocol/internal-utils";
 
 // src/lib/object.ts
 function pick(obj, keys) {
@@ -1672,7 +2106,7 @@ function configureEvmRpcUrls(defaultRpcUrls, userRpcUrls, supportedChains) {
     ).map(([caip2, urls]) => [getEIP155ChainId(caip2), urls])
   );
   for (const [chainId, urls] of Object.entries(evmRpcUrls)) {
-    assert10(
+    assert12(
       urls.length > 0,
       `EVM RPC URLs for chain ${chainId} are not provided`
     );
@@ -1686,7 +2120,7 @@ function configureStellarRpcUrls(defaultRpcUrls, userRpcUrls) {
     userRpcUrls?.[Chains.Stellar] ?? {}
   );
   for (const [key, value] of Object.entries(stellarRpcUrls)) {
-    assert10(value.length > 0, `Stellar RPC URL for ${key} is not provided`);
+    assert12(value.length > 0, `Stellar RPC URL for ${key} is not provided`);
   }
   return stellarRpcUrls;
 }
@@ -1698,8 +2132,10 @@ function createInternalTransferRoute() {
 function createNearWithdrawalRoute(msg) {
   return { route: RouteEnum.NearWithdrawal, msg };
 }
-function createOmniBridgeRoute() {
-  return { route: RouteEnum.OmniBridge };
+function createOmniBridgeRoute(chain) {
+  const routeConfig = { route: RouteEnum.OmniBridge };
+  if (chain) routeConfig.chain = chain;
+  return routeConfig;
 }
 function createVirtualChainRoute(auroraEngineContractId, proxyTokenContractId) {
   return {
@@ -1736,7 +2172,7 @@ function determineRouteConfig(sdk, withdrawalParams) {
     case BridgeNameEnum.Poa:
       return createPoaBridgeRoute(parseAssetId.blockchain);
     case BridgeNameEnum.Omni:
-      return createOmniBridgeRoute();
+      return createOmniBridgeRoute(parseAssetId.blockchain);
     case BridgeNameEnum.None:
       return createNearWithdrawalRoute();
     default:
@@ -1751,7 +2187,7 @@ var IntentsSDK = class {
     this.env = args.env ?? "production";
     this.referral = args.referral;
     const nearRpcUrls = args.rpc?.[Chains.Near] ?? PUBLIC_NEAR_RPC_URLS;
-    assert11(nearRpcUrls.length > 0, "NEAR RPC URLs are not provided");
+    assert13(nearRpcUrls.length > 0, "NEAR RPC URLs are not provided");
     const nearProvider = nearFailoverRpcProvider({ urls: nearRpcUrls });
     const stellarRpcUrls = configureStellarRpcUrls(
       PUBLIC_STELLAR_RPC_URLS,
@@ -1784,10 +2220,10 @@ var IntentsSDK = class {
           }
         })
       }),
-      // new OmniBridge({
-      // 	env: this.env,
-      // 	nearProvider,
-      // }),
+      new OmniBridge({
+        env: this.env,
+        nearProvider
+      }),
       new DirectBridge({
         env: this.env,
         nearProvider
@@ -1878,7 +2314,7 @@ var IntentsSDK = class {
       const routeConfig = determineRouteConfig(this, w);
       const route = routeConfig.route;
       const index = indexes.get(route);
-      assert11(index != null, "Index is not found for route");
+      assert13(index != null, "Index is not found for route");
       indexes.set(route, index + 1);
       return {
         routeConfig,
@@ -1912,7 +2348,7 @@ var IntentsSDK = class {
     if (Array.isArray(args.withdrawalParams)) {
       return result;
     }
-    assert11(result.length === 1, "Unexpected result length");
+    assert13(result.length === 1, "Unexpected result length");
     return result[0];
   }
   parseAssetId(assetId) {
@@ -1926,7 +2362,7 @@ var IntentsSDK = class {
   }
   async signAndSendIntent(args) {
     const intentSigner = args.signer ?? this.intentSigner;
-    assert11(intentSigner != null, "Intent signer is not provided");
+    assert13(intentSigner != null, "Intent signer is not provided");
     const intentExecuter = new IntentExecuter({
       env: this.env,
       logger: args.logger,
@@ -1995,12 +2431,12 @@ var IntentsSDK = class {
     intentHash,
     logger
   }) {
-    return solverRelay3.getStatus(
+    return solverRelay4.getStatus(
       {
         intent_hash: intentHash
       },
       {
-        baseURL: configsByEnvironment6[this.env].solverRelayBaseURL,
+        baseURL: configsByEnvironment7[this.env].solverRelayBaseURL,
         logger
       }
     );
@@ -2031,7 +2467,7 @@ var IntentsSDK = class {
       withdrawalParams,
       intentTx,
       logger: args.logger,
-      retryOptions: RETRY_CONFIGS2.FIVE_MINS_STEADY
+      retryOptions: RETRY_CONFIGS3.FIVE_MINS_STEADY
     });
     if (!Array.isArray(args.withdrawalParams)) {
       return {
@@ -2110,14 +2546,14 @@ var IntentSignerNearKeypair = class extends IntentSignerNEP413 {
 };
 
 // src/intents/intent-signer-impl/intent-signer-viem.ts
-import { utils as utils9 } from "@defuse-protocol/internal-utils";
+import { utils as utils10 } from "@defuse-protocol/internal-utils";
 var IntentSignerViem = class {
   constructor(account) {
     this.account = account;
   }
   async signIntent(intent) {
     const payload = JSON.stringify({
-      signer_id: intent.signer_id ?? utils9.authHandleToIntentsUserId({
+      signer_id: intent.signer_id ?? utils10.authHandleToIntentsUserId({
         identifier: this.account.address,
         method: "evm"
       }),
@@ -2135,7 +2571,7 @@ var IntentSignerViem = class {
     return {
       standard: "erc191",
       payload,
-      signature: utils9.transformERC191Signature(signature)
+      signature: utils10.transformERC191Signature(signature)
     };
   }
 };
@@ -2155,54 +2591,6 @@ function createIntentSignerViem(config) {
 import {
   BaseError as BaseError4
 } from "@defuse-protocol/internal-utils";
-
-// src/bridges/omni-bridge/error.ts
-import { BaseError as BaseError3 } from "@defuse-protocol/internal-utils";
-var OmniTransferNotFoundError = class extends BaseError3 {
-  constructor(txHash) {
-    super("Omni transfer with given hash is not found in the relayer.", {
-      metaMessages: [`OriginTxHash: ${txHash}`],
-      name: "OmniTransferNotFoundError"
-    });
-    this.txHash = txHash;
-  }
-};
-var OmniTransferDestinationChainHashNotFoundError = class extends BaseError3 {
-  constructor(txHash, destinationChain) {
-    super("Relayer did not return destination chain hash for a transfer.", {
-      metaMessages: [
-        `OriginTxHash: ${txHash}`,
-        `DestinationChain: ${destinationChain}`
-      ],
-      name: "OmniTransferDestinationChainHashNotFoundError"
-    });
-    this.txHash = txHash;
-    this.destinationChain = destinationChain;
-  }
-};
-var TokenNotSupportedByOmniRelayerError = class extends BaseError3 {
-  constructor(token) {
-    super(`Omni Relayer doesn't accept fee in the transferred token ${token}`, {
-      metaMessages: [`Token: ${token}`],
-      name: "TokenNotSupportedByOmniRelayerError"
-    });
-    this.token = token;
-  }
-};
-var TokenNotFoundInDestinationChainError = class extends BaseError3 {
-  constructor(token, chainKind) {
-    super(
-      `The token ${token} doesn't exist in destination network ${chainKind}`,
-      {
-        metaMessages: [`Token: ${token}`, `Destination Chain: ${chainKind}`],
-        name: "TokenNotFoundInDestinationChainError"
-      }
-    );
-    this.token = token;
-  }
-};
-
-// index.ts
 import {
   PoaWithdrawalInvariantError,
   PoaWithdrawalNotFoundError,