@cetusprotocol/aggregator-sdk 1.6.0 → 1.6.2

package/README.md

@@ -27,6 +27,8 @@ Easy Integration: The aggregator is designed to be simple and easy to integrate.
 
 Multi-Platform Support: Currently, we have integrated multiple mainstream DEXs on the Sui chain, including cetus, deepbook, kriya, flowx, aftermath, afsui, haedal, volo, turbos etc, allowing users to enjoy a diversified trading experience on a single platform.
 
+Sponsored Transactions: The SDK can build swap PTBs that do not use the user's gas coin, allowing a separate sponsor account to pay transaction gas.
+
 By using our aggregator, you can trade more efficiently and securely on the Sui blockchain, fully leveraging the various opportunities brought by decentralized finance (DeFi).
 
 # Aggregator SDK
@@ -55,7 +57,7 @@ const from = "0x2::sui::SUI"
 const target =
   "0x06864a6f921804860930db6ddbe2e16acdf8504495ea7481637a1c8b9a8fe54b::cetus::CETUS"
 
-const routers = await client.findRouters({
+const routerRes = await client.findRouters({
   from,
   target,
   amount,
@@ -70,7 +72,7 @@ const txb = new Transaction()
 
 if (routerRes != null) {
   await client.fastRouterSwap({
-    routers,
+    router: routerRes,
     txb,
     slippage: 0.01,
   })
@@ -85,7 +87,83 @@ if (routerRes != null) {
 }
 ```
 
-### 4. Build PTB and return target coin
+### 4. Sponsored transaction: sponsor pays gas
+
+Set `sponsored: true` when building the swap. In this mode the swap does not use `txb.gas` as input or output, because the gas coin belongs to the sponsor.
+
+```typescript
+import { Transaction } from "@mysten/sui/transactions"
+import { SUI_TYPE_ARG } from "@mysten/sui/utils"
+
+const sender = userSigner.toSuiAddress()
+const sponsor = sponsorSigner.toSuiAddress()
+const txb = new Transaction()
+
+await client.fastRouterSwap({
+  router: routerRes,
+  txb,
+  slippage: 0.01,
+  sponsored: true,
+})
+
+// Build command-only bytes. Pass sender so CoinWithBalance can resolve
+// the user's input coins before the sponsor adds gas data.
+const txKindBytes = await client.buildTransactionKind(txb, sender)
+
+const { objects: gasCoins } = await client.client.listCoins({
+  owner: sponsor,
+  coinType: SUI_TYPE_ARG,
+  limit: 1,
+})
+
+const sponsorCoins = gasCoins.map((coin) => ({
+  objectId: coin.objectId,
+  version: coin.version,
+  digest: coin.digest,
+}))
+
+const sponsoredTx = client.buildSponsoredTransaction({
+  txKindBytes,
+  sender,
+  sponsor,
+  sponsorCoins,
+  gasBudget: "100000000",
+})
+
+const result = await client.signAndExecuteSponsoredTransaction(
+  sponsoredTx,
+  userSigner,
+  sponsorSigner
+)
+```
+
+For a gas-station integration, the same flow is split across two parties: the user builds `txKindBytes`, the sponsor sets `gasOwner` and `gasPayment`, then both parties sign the same full transaction bytes.
+
+#### Sponsor secret for the real transaction test
+
+The real sponsored transaction test reuses the existing wallet secret as the user/sender and adds one sponsor secret:
+
+```bash
+SUI_WALLET_SECRET="user_base64_secret" \
+SUI_SPONSOR_SECRET="sponsor_base64_secret" \
+npx vitest run tests/unit/sponsored.test.ts
+```
+
+`SUI_WALLET_SECRET` owns the swap input coins and signs as the transaction sender. `SUI_SPONSOR_SECRET` owns the gas coin and signs as the gas sponsor. Use two different accounts; the sponsor account only needs enough SUI to cover `SPONSORED_GAS_BUDGET` (`100000000` MIST by default).
+
+Optional test variables:
+
+```bash
+SPONSORED_SWAP_AMOUNT=1000000
+SPONSORED_GAS_BUDGET=100000000
+SUI_RPC="https://fullnode.mainnet.sui.io:443"
+```
+
+If either secret is missing, `tests/unit/sponsored.test.ts` is skipped and no transaction is submitted.
+
+Keep both secrets in your local shell or `.env` file, and do not commit them.
+
+### 5. Build PTB and return target coin
 
 ```typescript
 const txb = new Transaction()
@@ -93,7 +171,7 @@ const byAmountIn = true
 
 if (routerRes != null) {
   const targetCoin = await client.routerSwap({
-    routers,
+    router: routerRes,
     txb,
     inputCoin,
     slippage: 0.01,
@@ -118,18 +196,18 @@ if (routerRes != null) {
 
 | Contract                  | Tag of Repo | Latest published at address                                        |
 | ------------------------- | ----------- | ------------------------------------------------------------------ |
-| CetusAggregatorV2         | mainnet     | 0x40e457bc65a398d2db7026881358fcb7cfa2f1bb052bca41f46c55a1103f2d6f |
+| CetusAggregatorV2         | mainnet     | 0x3a7fa58adcd7ff474ca0330c93068b139f5263c0cf9c64e702f5c4b17996ff10 |
 | CetusAggregatorV2ExtendV1 | mainnet     | 0x2edc22bf96c85482b2208624fa9339255d5055113c92fd6c33add48ce971b774 |
 | CetusAggregatorV2ExtendV2 | mainnet     | 0x2e227a3cbc6715518b18ed339d2f967153674b7b257da114ca62c72b2011258a |
 
 ## Example
 
 ```
-CetusAggregatorV2 = { git = "https://github.com/CetusProtocol/aggregator.git", subdir = "packages/cetus-aggregator-v2/mainnet", rev = "mainnet-v1.56.0", override = true }
+CetusAggregatorV2 = { git = "https://github.com/CetusProtocol/aggregator.git", subdir = "packages/cetus-aggregator-v2/mainnet", rev = "mainnet-v1.63.0", override = true }
 
-CetusAggregatorV2ExtendV1 = { git = "https://github.com/CetusProtocol/aggregator.git", subdir = "packages/cetus-aggregator-v2-extend-v1", rev = "mainnet-v1.56.0", override = true }
+CetusAggregatorV2ExtendV1 = { git = "https://github.com/CetusProtocol/aggregator.git", subdir = "packages/cetus-aggregator-v2-extend-v1", rev = "mainnet-v1.63.0", override = true }
 
-CetusAggregatorV2ExtendV2 = { git = "https://github.com/CetusProtocol/aggregator.git", subdir = "packages/cetus-aggregator-v2-extend-v2", rev = "mainnet-v1.56.0", override = true }
+CetusAggregatorV2ExtendV2 = { git = "https://github.com/CetusProtocol/aggregator.git", subdir = "packages/cetus-aggregator-v2-extend-v2", rev = "mainnet-v1.63.0", override = true }
 ```
 
 # Simple Aggregator Contract Interface
@@ -140,12 +218,12 @@ CetusAggregatorV2ExtendV2 = { git = "https://github.com/CetusProtocol/aggregator
 
 | Contract              | Tag of Repo | Latest published at address                                        |
 | --------------------- | ----------- | ------------------------------------------------------------------ |
-| CetusAggregatorSimple | mainnet     | 0x54394cb5bceb8073c60df0964b904a607c9974ef771d9e8b3f9c45b8ce075499 |
+| CetusAggregatorSimple | mainnet     | 0xf44ab76524a6b22a175968ae193a13f4905aea9b805afb6db51655b6b59db69e |
 
 ## Example
 
 ```
-CetusAggregatorSimple = { git = "https://github.com/CetusProtocol/aggregator.git", subdir = "packages/cetus-aggregator-v2/simple-mainnet", rev = "mainnet-v1.58.0", override = true }
+CetusAggregatorSimple = { git = "https://github.com/CetusProtocol/aggregator.git", subdir = "packages/cetus-aggregator-v2/simple-mainnet", rev = "mainnet-v1.63.0", override = true }
 ```
 
 ## Usage

package/dist/index.cjs

@@ -3416,7 +3416,7 @@ var AGGREGATOR_V3_CONFIG = {
 };
 
 // src/api.ts
-var SDK_VERSION = 1010600;
+var SDK_VERSION = 1010602;
 function parseRouterResponse(data, byAmountIn) {
   let packages = /* @__PURE__ */ new Map();
   if (data.packages) {
@@ -7822,20 +7822,56 @@ function transferOrDestroyCoin(params, txb) {
   });
 }
 var MAX_ARGUMENT_SIZE = 16 * 1024;
+var DEFAULT_HERMES_URL = "https://hermes.pyth.network";
+var DEFAULT_AVAILABILITY_TIMEOUT = 3e3;
+var DEFAULT_IS_AVAILABLE_STATUS = (status) => status >= 200 && status < 400;
 var PythAdapter = class {
   constructor(client, pythStateId, wormholeStateId, hermesUrls) {
     this.priceFeedObjectIdCache = /* @__PURE__ */ new Map();
     this.client = client;
     this.pythStateId = pythStateId;
     this.wormholeStateId = wormholeStateId;
-    const urls = [...hermesUrls];
-    if (!urls.includes("https://hermes.pyth.network")) {
-      urls.push("https://hermes.pyth.network");
+    const urls = Array.from(
+      new Set(hermesUrls.filter(Boolean).map(normalizeServiceUrl))
+    );
+    if (!urls.includes(DEFAULT_HERMES_URL)) {
+      urls.push(DEFAULT_HERMES_URL);
     }
+    this.hermesUrls = urls;
     this.hermesClients = urls.map(
       (url) => new hermesClient.HermesClient(url, { timeout: 3e3 })
     );
   }
+  getHermesUrls() {
+    return [...this.hermesUrls];
+  }
+  async checkHermesAvailability({
+    timeout = DEFAULT_AVAILABILITY_TIMEOUT,
+    isAvailableStatus = DEFAULT_IS_AVAILABLE_STATUS
+  } = {}) {
+    if (this.hermesUrls.length === 0) {
+      return {
+        checked: false,
+        availableUrls: [],
+        unavailableUrls: []
+      };
+    }
+    const results = await Promise.all(
+      this.hermesUrls.map(async (url) => ({
+        url,
+        available: await checkServiceUrl(url, timeout, isAvailableStatus)
+      }))
+    );
+    return {
+      checked: true,
+      availableUrls: results.filter((result) => result.available).map((result) => result.url),
+      unavailableUrls: results.filter((result) => !result.available).map((result) => result.url)
+    };
+  }
+  async isHermesAvailable(options) {
+    const snapshot = await this.checkHermesAvailability(options);
+    return snapshot.availableUrls.length > 0;
+  }
   async getPriceFeedsUpdateData(priceIDs) {
     let lastError = null;
     for (const hermes of this.hermesClients) {
@@ -8044,6 +8080,25 @@ var PythAdapter = class {
     return priceInfoObjects;
   }
 };
+async function checkServiceUrl(url, timeout, isAvailableStatus) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      cache: "no-store",
+      signal: controller.signal
+    });
+    return isAvailableStatus(response.status);
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function normalizeServiceUrl(url) {
+  return url.replace(/\/+$/, "");
+}
 
 // src/utils/uuid.ts
 function generateDowngradeUuid6() {
@@ -8948,6 +9003,12 @@ var ALL_DEXES = [
   MAGMAPROPAMM,
   HAEDALPROPAMM
 ];
+var PYTH_ORACLE_BASED_DEXES = [
+  HAEDALPMM,
+  METASTABLE,
+  STEAMM_OMM_V2,
+  HAEDALHMMV2
+];
 function getAllProviders() {
   return ALL_DEXES;
 }
@@ -9027,6 +9088,9 @@ var _AggregatorClient = class _AggregatorClient {
     this.apiKey = params.apiKey || "";
     this.partner = params.partner;
     this.cetusDlmmPartner = params.cetusDlmmPartner;
+    this.pythAvailabilityCheckInterval = validatePythAvailabilityCheckInterval(
+      params.pythAvailabilityCheckInterval
+    );
     if (params.overlayFeeRate) {
       if (params.overlayFeeRate > 0 && params.overlayFeeRate <= CLIENT_CONFIG.MAX_OVERLAY_FEE_RATE) {
         this.overlayFeeRate = params.overlayFeeRate * AGGREGATOR_V3_CONFIG.FEE_DENOMINATOR;
@@ -9069,23 +9133,74 @@ var _AggregatorClient = class _AggregatorClient {
     }
   }
   async findRouters(params) {
+    const {
+      params: routerParams,
+      providersExhausted
+    } = await this.filterProvidersByPythAvailability(params);
+    if (providersExhausted) {
+      return emptyRouterResult(routerParams.byAmountIn);
+    }
     return getRouterResult(
       this.endpoint,
       this.apiKey,
-      params,
+      routerParams,
       this.overlayFeeRate,
       this.overlayFeeReceiver
     );
   }
   async findMergeSwapRouters(params) {
+    const {
+      params: routerParams,
+      providersExhausted
+    } = await this.filterProvidersByPythAvailability(params);
+    if (providersExhausted) {
+      return emptyMergeSwapResult();
+    }
     return getMergeSwapResult(
       this.endpoint,
       this.apiKey,
-      params,
+      routerParams,
       this.overlayFeeRate,
       this.overlayFeeReceiver
     );
   }
+  async filterProvidersByPythAvailability(params) {
+    const interval = validatePythAvailabilityCheckInterval(
+      params.pythAvailabilityCheckInterval ?? this.pythAvailabilityCheckInterval
+    );
+    if (interval === void 0) {
+      return { params, providersExhausted: false };
+    }
+    const pythAvailable = await this.getPythAvailability(interval);
+    if (pythAvailable) {
+      return { params, providersExhausted: false };
+    }
+    const sourceProviders = params.providers && params.providers.length > 0 ? params.providers : ALL_DEXES;
+    const providers = sourceProviders.filter(
+      (provider) => !PYTH_ORACLE_BASED_DEXES.includes(provider)
+    );
+    return {
+      params: { ...params, providers },
+      providersExhausted: providers.length === 0
+    };
+  }
+  async getPythAvailability(interval) {
+    const now = Date.now();
+    if (this.pythAvailable !== void 0 && this.pythAvailabilityCheckedAt !== void 0 && now - this.pythAvailabilityCheckedAt < interval) {
+      return this.pythAvailable;
+    }
+    if (this.pythAvailabilityPromise) {
+      return this.pythAvailabilityPromise;
+    }
+    this.pythAvailabilityPromise = this.pythAdapter.isHermesAvailable().catch(() => false).then((available) => {
+      this.pythAvailable = available;
+      this.pythAvailabilityCheckedAt = Date.now();
+      return available;
+    }).finally(() => {
+      this.pythAvailabilityPromise = void 0;
+    });
+    return this.pythAvailabilityPromise;
+  }
   async executeFlexibleInputSwap(txb, inputCoin, routerData, expectedAmountOut, amountLimit, pythPriceIDs, partner, deepbookv3DeepFee, packages) {
   }
   newDexRouterV3(provider, pythPriceIDs, partner, cetusDlmmPartner) {
@@ -9589,7 +9704,15 @@ var _AggregatorClient = class _AggregatorClient {
   // auto build input coin
   // auto merge, transfer or destory target coin.
   async fastRouterSwap(params) {
-    const { router, slippage, txb, partner, cetusDlmmPartner, payDeepFeeAmount } = params;
+    const {
+      router,
+      slippage,
+      txb,
+      partner,
+      cetusDlmmPartner,
+      payDeepFeeAmount,
+      sponsored = false
+    } = params;
     const fromCoinType = router.paths[0].from;
     const targetCoinType = router.paths[router.paths.length - 1].target;
     const byAmountIn = router.byAmountIn;
@@ -9614,7 +9737,7 @@ var _AggregatorClient = class _AggregatorClient {
     const amount = byAmountIn ? expectedAmountIn : amountLimit;
     let inputCoin = transactions.coinWithBalance({
       balance: BigInt(amount.toString()),
-      useGasCoin: true,
+      useGasCoin: !sponsored,
       type: fromCoinType
     });
     let deepCoin;
@@ -9634,22 +9757,46 @@ var _AggregatorClient = class _AggregatorClient {
       deepbookv3DeepFee: deepCoin
     };
     const targetCoin = await this.routerSwap(routerSwapParams);
+    await this.deliverTargetCoin(
+      txb,
+      targetCoin,
+      targetCoinType,
+      router.packages,
+      sponsored
+    );
+  }
+  // Delivers a swap's output coin. In sponsored mode the SDK must not query or touch
+  // coins through `this.signer`, because the transaction sender may be different from
+  // the SDK instance signer. Let the router transfer helper deliver the output to the
+  // transaction sender instead.
+  async deliverTargetCoin(txb, targetCoin, targetCoinType, packages, sponsored) {
+    if (sponsored) {
+      transferOrDestroyCoin(
+        {
+          coin: targetCoin,
+          coinType: targetCoinType,
+          packages
+        },
+        txb
+      );
+      return;
+    }
     if (CoinUtils.isSuiCoin(targetCoinType)) {
       txb.mergeCoins(txb.gas, [targetCoin]);
+      return;
+    }
+    const targetCoinObjID = await this.getOneCoinUsedToMerge(targetCoinType);
+    if (targetCoinObjID != null) {
+      txb.mergeCoins(txb.object(targetCoinObjID), [targetCoin]);
     } else {
-      const targetCoinObjID = await this.getOneCoinUsedToMerge(targetCoinType);
-      if (targetCoinObjID != null) {
-        txb.mergeCoins(txb.object(targetCoinObjID), [targetCoin]);
-      } else {
-        transferOrDestroyCoin(
-          {
-            coin: targetCoin,
-            coinType: targetCoinType,
-            packages: router.packages
-          },
-          txb
-        );
-      }
+      transferOrDestroyCoin(
+        {
+          coin: targetCoin,
+          coinType: targetCoinType,
+          packages
+        },
+        txb
+      );
     }
   }
   async mergeSwap(params) {
@@ -9698,7 +9845,7 @@ var _AggregatorClient = class _AggregatorClient {
     return finalOutputCoin;
   }
   async fastMergeSwap(params) {
-    const { router, slippage, txb, partner } = params;
+    const { router, slippage, txb, partner, sponsored = false } = params;
     if (!router || !router.allRoutes || router.allRoutes.length === 0) {
       throw new Error("Invalid router: no routes found");
     }
@@ -9714,7 +9861,7 @@ var _AggregatorClient = class _AggregatorClient {
       coinTypeSet.add(firstCoinType);
       const coin = transactions.coinWithBalance({
         balance: BigInt(route.amountIn.toString()),
-        useGasCoin: CoinUtils.isSuiCoin(firstCoinType),
+        useGasCoin: !sponsored && CoinUtils.isSuiCoin(firstCoinType),
         type: firstCoinType
       });
       inputCoins.push({ coinType: firstCoinType, coin });
@@ -9727,23 +9874,13 @@ var _AggregatorClient = class _AggregatorClient {
       partner: partner ?? this.partner
     };
     const targetCoin = await this.mergeSwap(mergeSwapParams);
-    if (CoinUtils.isSuiCoin(targetCoinType)) {
-      txb.mergeCoins(txb.gas, [targetCoin]);
-    } else {
-      const targetCoinObjID = await this.getOneCoinUsedToMerge(targetCoinType);
-      if (targetCoinObjID != null) {
-        txb.mergeCoins(txb.object(targetCoinObjID), [targetCoin]);
-      } else {
-        transferOrDestroyCoin(
-          {
-            coin: targetCoin,
-            coinType: targetCoinType,
-            packages: router.packages
-          },
-          txb
-        );
-      }
-    }
+    await this.deliverTargetCoin(
+      txb,
+      targetCoin,
+      targetCoinType,
+      router.packages,
+      sponsored
+    );
   }
   async fixableRouterSwapV3(params) {
     const { router, inputCoin, slippage, txb, partner } = params;
@@ -9942,6 +10079,70 @@ var _AggregatorClient = class _AggregatorClient {
     });
     return res;
   }
+  // ---------------------------------------------------------------------------
+  // Sponsored transactions
+  //
+  // A sponsored transaction lets a sponsor (gas station) pay gas for a transaction
+  // whose commands are authored by a different sender. The sender and the sponsor both
+  // sign the same transaction bytes, and the transaction is submitted with both
+  // signatures. See: https://docs.sui.io/concepts/transactions/sponsored-transactions
+  //
+  // Build the swap with `sponsored: true` (e.g. `fastRouterSwap`/`fastMergeSwap`) so the
+  // gas coin is never used, then:
+  //   - Remote gas station: `buildTransactionKind(txb, sender)` -> station assembles gas
+  //     data with `buildSponsoredTransaction` -> station builds/signs full bytes -> user
+  //     signs the same bytes -> `executeWithSignatures`.
+  //   - Local sponsor (both keypairs available): `signAndExecuteSponsoredTransaction`.
+  // ---------------------------------------------------------------------------
+  // Builds the TransactionKind bytes (commands only, no gas data) to hand to a sponsor /
+  // gas station. Pass `sender` when the transaction contains CoinWithBalance intents,
+  // because those are resolved while building the kind.
+  async buildTransactionKind(txb, sender) {
+    if (sender) {
+      txb.setSender(sender);
+    }
+    return txb.build({ client: this.client, onlyTransactionKind: true });
+  }
+  // Assembles a sponsored transaction from TransactionKind bytes plus the gas data
+  // provided by the sponsor. The returned transaction is ready to be built and signed by
+  // both the sender and the sponsor.
+  buildSponsoredTransaction(params) {
+    const { txKindBytes, sender, sponsor, sponsorCoins, gasBudget, gasPrice } = params;
+    const tx = transactions.Transaction.fromKind(txKindBytes);
+    tx.setSender(sender);
+    tx.setGasOwner(sponsor);
+    tx.setGasPayment(sponsorCoins);
+    if (gasBudget != null) {
+      tx.setGasBudget(gasBudget);
+    }
+    if (gasPrice != null) {
+      tx.setGasPrice(gasPrice);
+    }
+    return tx;
+  }
+  // Builds the full transaction bytes (including gas data) that both parties must sign.
+  // Returns the exact bytes the signatures must be produced over.
+  async buildTransactionBytes(txb) {
+    return txb.build({ client: this.client });
+  }
+  // Executes a transaction from pre-built bytes plus the collected signatures. The
+  // signatures MUST be produced over exactly these `bytes` (see `buildTransactionBytes`).
+  async executeWithSignatures(bytes, signatures) {
+    return this.client.executeTransaction({
+      transaction: bytes,
+      signatures,
+      include: { effects: true, events: true, balanceChanges: true }
+    });
+  }
+  // Convenience for the local dual-key case: signs the transaction with both the user's
+  // and the sponsor's signer and executes it. `txb` must already have its sender, gas
+  // owner and gas payment set (e.g. via `buildSponsoredTransaction`).
+  async signAndExecuteSponsoredTransaction(txb, userSigner, sponsorSigner) {
+    const bytes = await txb.build({ client: this.client });
+    const { signature: sponsorSig } = await sponsorSigner.signTransaction(bytes);
+    const { signature: userSig } = await userSigner.signTransaction(bytes);
+    return this.executeWithSignatures(bytes, [userSig, sponsorSig]);
+  }
 };
 _AggregatorClient.CONFIG = {
   [1 /* Testnet */]: {
@@ -9961,6 +10162,35 @@ function generateUUID() {
     return v.toString(16);
   });
 }
+function validatePythAvailabilityCheckInterval(interval) {
+  if (interval === void 0) {
+    return void 0;
+  }
+  if (!Number.isFinite(interval) || interval < 0) {
+    throw new Error(
+      "pythAvailabilityCheckInterval must be a non-negative number"
+    );
+  }
+  return interval;
+}
+function emptyRouterResult(byAmountIn) {
+  return {
+    quoteID: "",
+    amountIn: ZERO,
+    amountOut: ZERO,
+    paths: [],
+    byAmountIn,
+    insufficientLiquidity: true,
+    deviationRatio: 0
+  };
+}
+function emptyMergeSwapResult() {
+  return {
+    quoteID: "",
+    totalAmountOut: ZERO,
+    allRoutes: []
+  };
+}
 function recordFirstCoinIndex(paths) {
   let newCoinRecord = /* @__PURE__ */ new Map();
   for (let i = 0; i < paths.length; i++) {
@@ -10100,6 +10330,7 @@ exports.PAY_MODULE = PAY_MODULE;
 exports.POOL_MODULT = POOL_MODULT;
 exports.PUBLISHED_ADDRESSES = PUBLISHED_ADDRESSES;
 exports.PYTH_CONFIG = PYTH_CONFIG;
+exports.PYTH_ORACLE_BASED_DEXES = PYTH_ORACLE_BASED_DEXES;
 exports.PYTH_PRELUDE_CALLS = PYTH_PRELUDE_CALLS;
 exports.REPAY_FLASH_SWAP_A2B_FUNC = REPAY_FLASH_SWAP_A2B_FUNC;
 exports.REPAY_FLASH_SWAP_B2A_FUNC = REPAY_FLASH_SWAP_B2A_FUNC;