@defuse-protocol/intents-sdk 0.16.1 → 0.16.3

package/dist/index.cjs

@@ -30,28 +30,28 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // index.ts
 var index_exports = {};
 __export(index_exports, {
-  AssertionError: () => import_internal_utils24.AssertionError,
-  BaseError: () => import_internal_utils21.BaseError,
+  AssertionError: () => import_internal_utils22.AssertionError,
+  BaseError: () => import_internal_utils19.BaseError,
   BridgeNameEnum: () => BridgeNameEnum,
   Chains: () => Chains,
   FeeExceedsAmountError: () => FeeExceedsAmountError,
   HotWithdrawalCancelledError: () => HotWithdrawalCancelledError,
   HotWithdrawalNotFoundError: () => HotWithdrawalNotFoundError,
   HotWithdrawalPendingError: () => HotWithdrawalPendingError,
-  HttpRequestError: () => import_internal_utils23.HttpRequestError,
-  IntentSettlementError: () => import_internal_utils25.IntentSettlementError,
+  HttpRequestError: () => import_internal_utils21.HttpRequestError,
+  IntentSettlementError: () => import_internal_utils23.IntentSettlementError,
   IntentsSDK: () => IntentsSDK,
   MinWithdrawalAmountError: () => MinWithdrawalAmountError,
   OmniTransferDestinationChainHashNotFoundError: () => OmniTransferDestinationChainHashNotFoundError,
   OmniTransferNotFoundError: () => OmniTransferNotFoundError,
-  PoaWithdrawalInvariantError: () => import_internal_utils22.PoaWithdrawalInvariantError,
-  PoaWithdrawalNotFoundError: () => import_internal_utils22.PoaWithdrawalNotFoundError,
-  PoaWithdrawalPendingError: () => import_internal_utils22.PoaWithdrawalPendingError,
-  QuoteError: () => import_internal_utils25.QuoteError,
-  RelayPublishError: () => import_internal_utils25.RelayPublishError,
+  PoaWithdrawalInvariantError: () => import_internal_utils20.PoaWithdrawalInvariantError,
+  PoaWithdrawalNotFoundError: () => import_internal_utils20.PoaWithdrawalNotFoundError,
+  PoaWithdrawalPendingError: () => import_internal_utils20.PoaWithdrawalPendingError,
+  QuoteError: () => import_internal_utils23.QuoteError,
+  RelayPublishError: () => import_internal_utils23.RelayPublishError,
   RouteEnum: () => RouteEnum,
-  RpcRequestError: () => import_internal_utils23.RpcRequestError,
-  TimeoutError: () => import_internal_utils23.TimeoutError,
+  RpcRequestError: () => import_internal_utils21.RpcRequestError,
+  TimeoutError: () => import_internal_utils21.TimeoutError,
   TokenNotFoundInDestinationChainError: () => TokenNotFoundInDestinationChainError,
   TokenNotSupportedByOmniRelayerError: () => TokenNotSupportedByOmniRelayerError,
   TrustlineNotFoundError: () => TrustlineNotFoundError,
@@ -70,7 +70,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/sdk.ts
-var import_internal_utils19 = require("@defuse-protocol/internal-utils");
+var import_internal_utils16 = require("@defuse-protocol/internal-utils");
 var import_omni_sdk3 = __toESM(require("@hot-labs/omni-sdk"), 1);
 var import_viem2 = require("viem");
 
@@ -816,407 +816,14 @@ var IntentsBridge = class {
   }
 };
 
-// src/bridges/omni-bridge/omni-bridge.ts
-var import_internal_utils12 = require("@defuse-protocol/internal-utils");
+// src/bridges/poa-bridge/poa-bridge.ts
+var import_internal_utils11 = require("@defuse-protocol/internal-utils");
 var import_ttlcache = __toESM(require("@isaacs/ttlcache"), 1);
-var import_attempt2 = require("@lifeomic/attempt");
-var import_omni_bridge_sdk2 = require("omni-bridge-sdk");
 
-// src/bridges/omni-bridge/error.ts
+// src/bridges/poa-bridge/poa-bridge-utils.ts
 var import_internal_utils10 = require("@defuse-protocol/internal-utils");
-var OmniTransferNotFoundError = class extends import_internal_utils10.BaseError {
-  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 import_internal_utils10.BaseError {
-  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 import_internal_utils10.BaseError {
-  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 import_internal_utils10.BaseError {
-  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;
-  }
-};
-
-// 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
-var import_internal_utils11 = require("@defuse-protocol/internal-utils");
-var import_omni_bridge_sdk = require("omni-bridge-sdk");
 function createWithdrawIntentPrimitive3(params) {
-  const { contractId: tokenAccountId, standard } = import_internal_utils11.utils.parseDefuseAssetId(
-    params.assetId
-  );
-  (0, import_internal_utils11.assert)(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: (0, import_omni_bridge_sdk.omniAddress)(
-        caip2ToChainKind(params.origin),
-        params.destinationAddress
-      ),
-      fee: params.transferredTokenFee.toString(),
-      native_token_fee: "0"
-    })
-  };
-}
-function targetChainSupportedByOmniBridge(network) {
-  switch (network) {
-    case Chains.Ethereum:
-      return true;
-    case Chains.Base:
-      return true;
-    case Chains.Arbitrum:
-      return true;
-    case Chains.Solana:
-      return true;
-    case Chains.Bitcoin:
-      return true;
-    default:
-      return false;
-  }
-}
-function caip2ToChainKind(network) {
-  switch (network) {
-    case Chains.Ethereum:
-      return import_omni_bridge_sdk.ChainKind.Eth;
-    case Chains.Base:
-      return import_omni_bridge_sdk.ChainKind.Base;
-    case Chains.Arbitrum:
-      return import_omni_bridge_sdk.ChainKind.Arb;
-    case Chains.Solana:
-      return import_omni_bridge_sdk.ChainKind.Sol;
-    case Chains.Bitcoin:
-      return import_omni_bridge_sdk.ChainKind.Btc;
-    default:
-      throw new Error(`Unsupported Omni network = ${network}`);
-  }
-}
-function chainKindToCaip2(network) {
-  switch (network) {
-    case import_omni_bridge_sdk.ChainKind.Eth:
-      return Chains.Ethereum;
-    case import_omni_bridge_sdk.ChainKind.Base:
-      return Chains.Base;
-    case import_omni_bridge_sdk.ChainKind.Arb:
-      return Chains.Arbitrum;
-    case import_omni_bridge_sdk.ChainKind.Sol:
-      return Chains.Solana;
-    case import_omni_bridge_sdk.ChainKind.Btc:
-      return Chains.Bitcoin;
-    default:
-      throw new Error(`Unsupported Caip2 network = ${network}`);
-  }
-}
-
-// src/bridges/omni-bridge/omni-bridge.ts
-var _OmniBridge = class _OmniBridge {
-  // 86400000 - 1 day
-  constructor({
-    env,
-    nearProvider
-  }) {
-    this.storageDepositCache = new import_ttlcache.default({ ttl: 864e5 });
-    // TTL cache for supported tokens with 30-second TTL
-    this.supportedTokensCache = new import_ttlcache.default({ ttl: 864e5 });
-    // 86400000 - 1 day
-    this.destinationChainAddressCache = new import_ttlcache.default({ ttl: 864e5 });
-    this.env = env;
-    this.nearProvider = nearProvider;
-    this.omniBridgeAPI = new import_omni_bridge_sdk2.OmniBridgeAPI();
-  }
-  is(routeConfig) {
-    return routeConfig.route === RouteEnum.OmniBridge;
-  }
-  supports(params) {
-    try {
-      if (this.targetChainSpecified(params.routeConfig)) {
-        return targetChainSupportedByOmniBridge(params.routeConfig.chain);
-      }
-      return this.parseAssetId(params.assetId) !== null;
-    } catch {
-      return false;
-    }
-  }
-  targetChainSpecified(routeConfig) {
-    return Boolean(
-      routeConfig?.route && routeConfig.route === RouteEnum.OmniBridge && routeConfig.chain
-    );
-  }
-  parseAssetId(assetId) {
-    const parsed = import_internal_utils12.utils.parseDefuseAssetId(assetId);
-    if (parsed.standard !== "nep141") return null;
-    const chain = (0, import_omni_bridge_sdk2.parseOriginChain)(parsed.contractId);
-    if (chain === null) return null;
-    return Object.assign(parsed, {
-      blockchain: chainKindToCaip2(chain),
-      bridgeName: BridgeNameEnum.Omni,
-      address: parsed.contractId
-    });
-  }
-  async tokenSupported(assetId, routeConfig) {
-    const parsed = import_internal_utils12.utils.parseDefuseAssetId(assetId);
-    if (parsed.standard !== "nep141") return null;
-    if (this.targetChainSpecified(routeConfig)) {
-      const tokenOnDestinationNetwork = await this.getCachedDestinationTokenAddress(
-        parsed.contractId,
-        routeConfig.chain
-      );
-      if (tokenOnDestinationNetwork === null) {
-        throw new TokenNotFoundInDestinationChainError(
-          assetId,
-          routeConfig.chain
-        );
-      }
-      return Object.assign(parsed, {
-        blockchain: routeConfig.chain,
-        bridgeName: BridgeNameEnum.Omni,
-        address: parsed.contractId
-      });
-    }
-    const chain = (0, import_omni_bridge_sdk2.parseOriginChain)(parsed.contractId);
-    if (chain === null) return null;
-    return Object.assign(parsed, {
-      blockchain: chainKindToCaip2(chain),
-      bridgeName: BridgeNameEnum.Omni,
-      address: parsed.contractId
-    });
-  }
-  async createWithdrawalIntents(args) {
-    const assetInfo = await this.tokenSupported(
-      args.withdrawalParams.assetId,
-      args.withdrawalParams.routeConfig
-    );
-    (0, import_internal_utils12.assert)(
-      assetInfo !== null,
-      `Asset ${args.withdrawalParams.assetId} is not supported`
-    );
-    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 intent = createWithdrawIntentPrimitive3({
-      assetId: args.withdrawalParams.assetId,
-      destinationAddress: args.withdrawalParams.destinationAddress,
-      amount: args.withdrawalParams.amount + args.feeEstimation.amount,
-      origin: assetInfo.blockchain,
-      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) {
-    const assetInfo = await this.tokenSupported(args.assetId, args.routeConfig);
-    (0, import_internal_utils12.assert)(assetInfo !== null, `Asset ${args.assetId} is not supported`);
-    const supportedTokens = await this.getCachedSupportedTokens();
-    if (!supportedTokens[assetInfo.contractId]) {
-      throw new TokenNotSupportedByOmniRelayerError(args.assetId);
-    }
-    (0, import_internal_utils12.assert)(
-      args.feeEstimation.amount > 0n,
-      `Fee must be greater than zero. Current fee is ${args.feeEstimation.amount}.`
-    );
-    return;
-  }
-  async estimateWithdrawalFee(args) {
-    const assetInfo = await this.tokenSupported(
-      args.withdrawalParams.assetId,
-      args.withdrawalParams.routeConfig
-    );
-    (0, import_internal_utils12.assert)(
-      assetInfo !== null,
-      `Asset ${args.withdrawalParams.assetId} is not supported`
-    );
-    const fee = await this.omniBridgeAPI.getFee(
-      (0, import_omni_bridge_sdk2.omniAddress)(import_omni_bridge_sdk2.ChainKind.Near, import_internal_utils12.configsByEnvironment[this.env].contractID),
-      (0, import_omni_bridge_sdk2.omniAddress)(
-        caip2ToChainKind(assetInfo.blockchain),
-        args.withdrawalParams.destinationAddress
-      ),
-      (0, import_omni_bridge_sdk2.omniAddress)(import_omni_bridge_sdk2.ChainKind.Near, assetInfo.contractId)
-    );
-    (0, import_internal_utils12.assert)(
-      fee.transferred_token_fee !== null,
-      `Asset ${args.withdrawalParams.assetId} is not supported by the relayer`
-    );
-    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 import_internal_utils12.solverRelay.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: import_internal_utils12.configsByEnvironment[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 (0, import_attempt2.retry)(
-      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 = (0, import_omni_bridge_sdk2.getChain)(
-          transfer.transfer_message.recipient
-        );
-        let txHash = null;
-        if ((0, import_omni_bridge_sdk2.isEvmChain)(destinationChain)) {
-          txHash = transfer.finalised?.EVMLog?.transaction_hash;
-        } else if (destinationChain === import_omni_bridge_sdk2.ChainKind.Sol) {
-          txHash = transfer.finalised?.Solana?.signature;
-        } else {
-          return { hash: null };
-        }
-        if (!txHash)
-          throw new OmniTransferDestinationChainHashNotFoundError(
-            args.tx.hash,
-            import_omni_bridge_sdk2.ChainKind[destinationChain].toLowerCase()
-          );
-        return { hash: txHash };
-      },
-      {
-        ...args.retryOptions ?? import_internal_utils12.RETRY_CONFIGS.TWO_MINS_GRADUAL,
-        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 != null) {
-      return cached;
-    }
-    const data = await Promise.all([
-      (0, import_internal_utils12.getNearNep141MinStorageBalance)({
-        contractId,
-        nearProvider: this.nearProvider
-      }),
-      (0, import_internal_utils12.getNearNep141StorageBalance)({
-        contractId,
-        accountId: OMNI_BRIDGE_CONTRACT,
-        nearProvider: this.nearProvider
-      })
-    ]);
-    this.storageDepositCache.set(contractId, data);
-    return data;
-  }
-  /**
-   * Gets cached tokens supported by the omni relayer, tokens not listed there can't be transferred.
-   * Cache expires after one day using TTL cache.
-   */
-  async getCachedSupportedTokens() {
-    const cached = this.supportedTokensCache.get(
-      _OmniBridge.SUPPORTED_TOKENS_CACHE_KEY
-    );
-    if (cached != null) {
-      return cached;
-    }
-    const data = await this.omniBridgeAPI.getAllowlistedTokens();
-    this.supportedTokensCache.set(_OmniBridge.SUPPORTED_TOKENS_CACHE_KEY, data);
-    return data;
-  }
-  /**
-   * Gets cached token address on destination chain.
-   * Cache expires after one day using TTL cache.
-   */
-  async getCachedDestinationTokenAddress(contractId, chain) {
-    const key = `${chain}:${contractId}`;
-    const cached = this.destinationChainAddressCache.get(key);
-    if (cached != null) {
-      return cached;
-    }
-    const tokenOnDestinationNetwork = await (0, import_omni_bridge_sdk2.getBridgedToken)(
-      (0, import_omni_bridge_sdk2.omniAddress)(import_omni_bridge_sdk2.ChainKind.Near, contractId),
-      caip2ToChainKind(chain)
-    );
-    this.destinationChainAddressCache.set(key, tokenOnDestinationNetwork);
-    return tokenOnDestinationNetwork;
-  }
-};
-// 86400000 - 1 day
-_OmniBridge.SUPPORTED_TOKENS_CACHE_KEY = "SUPPORTED_TOKENS_CACHE_KEY";
-var OmniBridge = _OmniBridge;
-
-// src/bridges/poa-bridge/poa-bridge.ts
-var import_internal_utils14 = require("@defuse-protocol/internal-utils");
-var import_ttlcache2 = __toESM(require("@isaacs/ttlcache"), 1);
-
-// src/bridges/poa-bridge/poa-bridge-utils.ts
-var import_internal_utils13 = require("@defuse-protocol/internal-utils");
-function createWithdrawIntentPrimitive4(params) {
-  const { contractId: tokenAccountId } = import_internal_utils13.utils.parseDefuseAssetId(
+  const { contractId: tokenAccountId } = import_internal_utils10.utils.parseDefuseAssetId(
     params.assetId
   );
   return {
@@ -1291,7 +898,7 @@ function contractIdToCaip2(contractId) {
 var PoaBridge = class {
   constructor({ env }) {
     // TTL cache for supported tokens with 30-second TTL
-    this.supportedTokensCache = new import_ttlcache2.default({ ttl: 30 * 1e3 });
+    this.supportedTokensCache = new import_ttlcache.default({ ttl: 30 * 1e3 });
     this.env = env;
   }
   is(routeConfig) {
@@ -1309,9 +916,9 @@ var PoaBridge = class {
     }
   }
   parseAssetId(assetId) {
-    const parsed = import_internal_utils14.utils.parseDefuseAssetId(assetId);
+    const parsed = import_internal_utils11.utils.parseDefuseAssetId(assetId);
     if (parsed.contractId.endsWith(
-      `.${import_internal_utils14.configsByEnvironment[this.env].poaTokenFactoryContractID}`
+      `.${import_internal_utils11.configsByEnvironment[this.env].poaTokenFactoryContractID}`
     )) {
       return Object.assign(parsed, {
         blockchain: contractIdToCaip2(parsed.contractId),
@@ -1323,7 +930,7 @@ var PoaBridge = class {
     return null;
   }
   createWithdrawalIntents(args) {
-    const intent = createWithdrawIntentPrimitive4({
+    const intent = createWithdrawIntentPrimitive3({
       ...args.withdrawalParams,
       amount: args.withdrawalParams.amount + args.feeEstimation.amount,
       destinationMemo: args.withdrawalParams.destinationMemo
@@ -1338,7 +945,7 @@ var PoaBridge = class {
    */
   async validateWithdrawal(args) {
     const assetInfo = this.parseAssetId(args.assetId);
-    (0, import_internal_utils14.assert)(assetInfo != null, "Asset is not supported");
+    (0, import_internal_utils11.assert)(assetInfo != null, "Asset is not supported");
     const { tokens } = await this.getCachedSupportedTokens(
       [toPoaNetwork(assetInfo.blockchain)],
       args.logger
@@ -1359,16 +966,16 @@ var PoaBridge = class {
   }
   async estimateWithdrawalFee(args) {
     const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
-    (0, import_internal_utils14.assert)(assetInfo != null, "Asset is not supported");
-    const estimation = await import_internal_utils14.poaBridge.httpClient.getWithdrawalEstimate(
+    (0, import_internal_utils11.assert)(assetInfo != null, "Asset is not supported");
+    const estimation = await import_internal_utils11.poaBridge.httpClient.getWithdrawalEstimate(
       {
-        token: import_internal_utils14.utils.getTokenAccountId(args.withdrawalParams.assetId),
+        token: import_internal_utils11.utils.getTokenAccountId(args.withdrawalParams.assetId),
         address: args.withdrawalParams.destinationAddress,
         // biome-ignore lint/suspicious/noExplicitAny: <explanation>
         chain: toPoaNetwork(assetInfo.blockchain)
       },
       {
-        baseURL: import_internal_utils14.configsByEnvironment[this.env].poaBridgeBaseURL,
+        baseURL: import_internal_utils11.configsByEnvironment[this.env].poaBridgeBaseURL,
         logger: args.logger
       }
     );
@@ -1378,12 +985,12 @@ var PoaBridge = class {
     };
   }
   async waitForWithdrawalCompletion(args) {
-    const withdrawalStatus = await import_internal_utils14.poaBridge.waitForWithdrawalCompletion({
+    const withdrawalStatus = await import_internal_utils11.poaBridge.waitForWithdrawalCompletion({
       txHash: args.tx.hash,
       index: args.index,
       signal: args.signal ?? new AbortController().signal,
       retryOptions: args.retryOptions,
-      baseURL: import_internal_utils14.configsByEnvironment[this.env].poaBridgeBaseURL,
+      baseURL: import_internal_utils11.configsByEnvironment[this.env].poaBridgeBaseURL,
       logger: args.logger
     });
     return { hash: withdrawalStatus.destinationTxHash };
@@ -1398,10 +1005,10 @@ var PoaBridge = class {
     if (cached != null) {
       return cached;
     }
-    const data = await import_internal_utils14.poaBridge.httpClient.getSupportedTokens(
+    const data = await import_internal_utils11.poaBridge.httpClient.getSupportedTokens(
       { chains },
       {
-        baseURL: import_internal_utils14.configsByEnvironment[this.env].poaBridgeBaseURL,
+        baseURL: import_internal_utils11.configsByEnvironment[this.env].poaBridgeBaseURL,
         logger
       }
     );
@@ -1423,7 +1030,7 @@ var PUBLIC_STELLAR_RPC_URLS = {
 };
 
 // src/intents/intent-executer-impl/intent-executer.ts
-var import_internal_utils15 = require("@defuse-protocol/internal-utils");
+var import_internal_utils12 = require("@defuse-protocol/internal-utils");
 
 // ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_u64.js
 var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
@@ -1804,7 +1411,7 @@ var IntentExecuter = class {
     relayParams: relayParamsFactory,
     ...intentParams
   }) {
-    const verifyingContract = import_internal_utils15.configsByEnvironment[this.env].contractID;
+    const verifyingContract = import_internal_utils12.configsByEnvironment[this.env].contractID;
     let intentPayload = defaultIntentPayloadFactory({
       verifying_contract: verifyingContract,
       ...intentParams
@@ -1854,7 +1461,7 @@ async function mergeIntentPayloads(basePayload, intentPayloadFactory) {
 }
 
 // src/intents/intent-relayer-impl/intent-relayer-public.ts
-var import_internal_utils16 = require("@defuse-protocol/internal-utils");
+var import_internal_utils13 = require("@defuse-protocol/internal-utils");
 var IntentRelayerPublic = class {
   constructor({ env }) {
     this.env = env;
@@ -1876,13 +1483,13 @@ var IntentRelayerPublic = class {
     multiPayloads,
     quoteHashes
   }, ctx = {}) {
-    const a = await import_internal_utils16.solverRelay.publishIntents(
+    const a = await import_internal_utils13.solverRelay.publishIntents(
       {
         quote_hashes: quoteHashes,
         signed_datas: multiPayloads
       },
       {
-        baseURL: import_internal_utils16.configsByEnvironment[this.env].solverRelayBaseURL,
+        baseURL: import_internal_utils13.configsByEnvironment[this.env].solverRelayBaseURL,
         logger: ctx.logger
       }
     );
@@ -1892,10 +1499,10 @@ var IntentRelayerPublic = class {
     throw a.unwrapErr();
   }
   async waitForSettlement(ticket, ctx = {}) {
-    const result = await import_internal_utils16.solverRelay.waitForIntentSettlement({
+    const result = await import_internal_utils13.solverRelay.waitForIntentSettlement({
       intentHash: ticket,
       signal: new AbortController().signal,
-      baseURL: import_internal_utils16.configsByEnvironment[this.env].solverRelayBaseURL,
+      baseURL: import_internal_utils13.configsByEnvironment[this.env].solverRelayBaseURL,
       logger: ctx.logger
     });
     return {
@@ -1903,7 +1510,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: import_internal_utils16.configsByEnvironment[this.env].contractID
+        accountId: import_internal_utils13.configsByEnvironment[this.env].contractID
       }
     };
   }
@@ -1917,14 +1524,14 @@ var noopIntentSigner = {
 };
 
 // src/lib/array.ts
-var import_internal_utils17 = require("@defuse-protocol/internal-utils");
+var import_internal_utils14 = require("@defuse-protocol/internal-utils");
 function zip(arr1, arr2) {
-  (0, import_internal_utils17.assert)(arr1.length === arr2.length, "Arrays must have the same length");
+  (0, import_internal_utils14.assert)(arr1.length === arr2.length, "Arrays must have the same length");
   return arr1.map((v, i) => [v, arr2[i]]);
 }
 
 // src/lib/configure-rpc-config.ts
-var import_internal_utils18 = require("@defuse-protocol/internal-utils");
+var import_internal_utils15 = require("@defuse-protocol/internal-utils");
 
 // src/lib/object.ts
 function pick(obj, keys) {
@@ -1948,7 +1555,7 @@ function configureEvmRpcUrls(defaultRpcUrls, userRpcUrls, supportedChains) {
     ).map(([caip2, urls]) => [getEIP155ChainId(caip2), urls])
   );
   for (const [chainId, urls] of Object.entries(evmRpcUrls)) {
-    (0, import_internal_utils18.assert)(
+    (0, import_internal_utils15.assert)(
       urls.length > 0,
       `EVM RPC URLs for chain ${chainId} are not provided`
     );
@@ -1962,7 +1569,7 @@ function configureStellarRpcUrls(defaultRpcUrls, userRpcUrls) {
     userRpcUrls?.[Chains.Stellar] ?? {}
   );
   for (const [key, value] of Object.entries(stellarRpcUrls)) {
-    (0, import_internal_utils18.assert)(value.length > 0, `Stellar RPC URL for ${key} is not provided`);
+    (0, import_internal_utils15.assert)(value.length > 0, `Stellar RPC URL for ${key} is not provided`);
   }
   return stellarRpcUrls;
 }
@@ -2032,9 +1639,9 @@ var IntentsSDK = class {
   constructor(args) {
     this.env = args.env ?? "production";
     this.referral = args.referral;
-    const nearRpcUrls = args.rpc?.[Chains.Near] ?? import_internal_utils19.PUBLIC_NEAR_RPC_URLS;
-    (0, import_internal_utils19.assert)(nearRpcUrls.length > 0, "NEAR RPC URLs are not provided");
-    const nearProvider = (0, import_internal_utils19.nearFailoverRpcProvider)({ urls: nearRpcUrls });
+    const nearRpcUrls = args.rpc?.[Chains.Near] ?? import_internal_utils16.PUBLIC_NEAR_RPC_URLS;
+    (0, import_internal_utils16.assert)(nearRpcUrls.length > 0, "NEAR RPC URLs are not provided");
+    const nearProvider = (0, import_internal_utils16.nearFailoverRpcProvider)({ urls: nearRpcUrls });
     const stellarRpcUrls = configureStellarRpcUrls(
       PUBLIC_STELLAR_RPC_URLS,
       args.rpc
@@ -2066,10 +1673,10 @@ var IntentsSDK = class {
           }
         })
       }),
-      new OmniBridge({
-        env: this.env,
-        nearProvider
-      }),
+      // new OmniBridge({
+      // 	env: this.env,
+      // 	nearProvider,
+      // }),
       new DirectBridge({
         env: this.env,
         nearProvider
@@ -2160,7 +1767,7 @@ var IntentsSDK = class {
       const routeConfig = determineRouteConfig(this, w);
       const route = routeConfig.route;
       const index = indexes.get(route);
-      (0, import_internal_utils19.assert)(index != null, "Index is not found for route");
+      (0, import_internal_utils16.assert)(index != null, "Index is not found for route");
       indexes.set(route, index + 1);
       return {
         routeConfig,
@@ -2194,7 +1801,7 @@ var IntentsSDK = class {
     if (Array.isArray(args.withdrawalParams)) {
       return result;
     }
-    (0, import_internal_utils19.assert)(result.length === 1, "Unexpected result length");
+    (0, import_internal_utils16.assert)(result.length === 1, "Unexpected result length");
     return result[0];
   }
   parseAssetId(assetId) {
@@ -2208,7 +1815,7 @@ var IntentsSDK = class {
   }
   async signAndSendIntent(args) {
     const intentSigner = args.signer ?? this.intentSigner;
-    (0, import_internal_utils19.assert)(intentSigner != null, "Intent signer is not provided");
+    (0, import_internal_utils16.assert)(intentSigner != null, "Intent signer is not provided");
     const intentExecuter = new IntentExecuter({
       env: this.env,
       logger: args.logger,
@@ -2277,12 +1884,12 @@ var IntentsSDK = class {
     intentHash,
     logger
   }) {
-    return import_internal_utils19.solverRelay.getStatus(
+    return import_internal_utils16.solverRelay.getStatus(
       {
         intent_hash: intentHash
       },
       {
-        baseURL: import_internal_utils19.configsByEnvironment[this.env].solverRelayBaseURL,
+        baseURL: import_internal_utils16.configsByEnvironment[this.env].solverRelayBaseURL,
         logger
       }
     );
@@ -2313,7 +1920,7 @@ var IntentsSDK = class {
       withdrawalParams,
       intentTx,
       logger: args.logger,
-      retryOptions: import_internal_utils19.RETRY_CONFIGS.FIVE_MINS_STEADY
+      retryOptions: import_internal_utils16.RETRY_CONFIGS.FIVE_MINS_STEADY
     });
     if (!Array.isArray(args.withdrawalParams)) {
       return {
@@ -2392,14 +1999,14 @@ var IntentSignerNearKeypair = class extends IntentSignerNEP413 {
 };
 
 // src/intents/intent-signer-impl/intent-signer-viem.ts
-var import_internal_utils20 = require("@defuse-protocol/internal-utils");
+var import_internal_utils17 = require("@defuse-protocol/internal-utils");
 var IntentSignerViem = class {
   constructor(account) {
     this.account = account;
   }
   async signIntent(intent) {
     const payload = JSON.stringify({
-      signer_id: intent.signer_id ?? import_internal_utils20.utils.authHandleToIntentsUserId({
+      signer_id: intent.signer_id ?? import_internal_utils17.utils.authHandleToIntentsUserId({
         identifier: this.account.address,
         method: "evm"
       }),
@@ -2417,7 +2024,7 @@ var IntentSignerViem = class {
     return {
       standard: "erc191",
       payload,
-      signature: import_internal_utils20.utils.transformERC191Signature(signature)
+      signature: import_internal_utils17.utils.transformERC191Signature(signature)
     };
   }
 };
@@ -2434,11 +2041,59 @@ function createIntentSignerViem(config) {
 }
 
 // index.ts
+var import_internal_utils19 = require("@defuse-protocol/internal-utils");
+
+// src/bridges/omni-bridge/error.ts
+var import_internal_utils18 = require("@defuse-protocol/internal-utils");
+var OmniTransferNotFoundError = class extends import_internal_utils18.BaseError {
+  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 import_internal_utils18.BaseError {
+  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 import_internal_utils18.BaseError {
+  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 import_internal_utils18.BaseError {
+  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
+var import_internal_utils20 = require("@defuse-protocol/internal-utils");
 var import_internal_utils21 = require("@defuse-protocol/internal-utils");
 var import_internal_utils22 = require("@defuse-protocol/internal-utils");
 var import_internal_utils23 = require("@defuse-protocol/internal-utils");
-var import_internal_utils24 = require("@defuse-protocol/internal-utils");
-var import_internal_utils25 = require("@defuse-protocol/internal-utils");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AssertionError,