@funkit/fun-relay 2.2.0-next.5 → 2.2.0

package/dist/index.mjs

@@ -96,90 +96,6 @@ function getRelayClient() {
 import {
   MAINNET_RELAY_API as MAINNET_RELAY_API2
 } from "@relayprotocol/relay-sdk";
-
-// src/utils.ts
-function convertFunToRelayTokenAddress(address, chainId) {
-  if (address.toLowerCase() === FUNKIT_NATIVE_TOKEN.toLowerCase()) {
-    switch (chainId) {
-      case FUN_HYPERCORE_CHAIN_ID_NUMBER:
-        return RELAY_NATIVE_TOKEN_HYPERCORE;
-      case RELAY_BITCOIN_CHAIN_ID_NUMBER:
-        return RELAY_NATIVE_TOKEN_BITCOIN;
-      // TODO: is it correct to assume chainId here is relay chain id?
-      case RELAY_SOLANA_CHAIN_ID_NUMBER:
-      case FUN_SOLANA_CHAIN_ID_NUMBER:
-        return RELAY_NATIVE_TOKEN_SOLANA;
-      case RELAY_LIGHTER_CHAIN_ID_NUMBER:
-        return RELAY_LIGHTER_USDC_PERPS;
-      default:
-        return RELAY_NATIVE_TOKEN;
-    }
-  }
-  if (RELAY_LIGHTER_CHAIN_ID_NUMBER === chainId) {
-    const relayAddress = RELAY_LIGHTER_FUN_ADDRESS_MAP[address.toLowerCase()];
-    if (relayAddress) {
-      return relayAddress;
-    }
-  }
-  return address;
-}
-function convertFunToRelayChainId(chainId) {
-  if (chainId === FUN_SOLANA_CHAIN_ID_NUMBER) {
-    return RELAY_SOLANA_CHAIN_ID_NUMBER;
-  }
-  return chainId;
-}
-function getRelayExecutionRefundState(info) {
-  switch (info.status) {
-    case "refund" /* REFUND */:
-      return "REFUNDED" /* REFUNDED */;
-    default:
-      return void 0;
-  }
-}
-function getRelayExecutionState(info) {
-  switch (info.status) {
-    case "success" /* SUCCESS */:
-      return "COMPLETED" /* COMPLETED */;
-    case "failure" /* FAILURE */:
-    case "refund" /* REFUND */:
-      return "CHECKOUT_ERROR" /* CHECKOUT_ERROR */;
-    default:
-      return "PENDING_RECEIVAL" /* PENDING_RECEIVAL */;
-  }
-}
-function isRelayExecutionTerminalStatus(info) {
-  return RELAY_TERMINAL_STATUSES.includes(info.status);
-}
-function jsonStringifyWithBigIntSanitization(serializable) {
-  return JSON.stringify(
-    serializable,
-    (_, value) => typeof value === "bigint" ? `0x${value.toString(16)}` : value
-    // return everything else unchanged
-  );
-}
-function indexBy(items, getKey) {
-  const indexedItems = {};
-  for (const item of items) {
-    const key = getKey(item);
-    if (!key) {
-      continue;
-    }
-    indexedItems[key] = item;
-  }
-  return indexedItems;
-}
-function filterNullishHeaders(params) {
-  const result = {};
-  for (const [key, value] of Object.entries(params)) {
-    if (value != null) {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-
-// src/execution.ts
 function getTxHash({
   logger,
   transactionType,
@@ -330,18 +246,6 @@ async function executeRelayQuote({
         ) {
           logger.info(`${logPrefix}:onTransactionConfirmed`, txHashes);
           isTransactionConfirmed = true;
-          const firstStep = relayQuote.steps[0];
-          const firstItem = firstStep?.items[0];
-          if (firstStep?.requestId && firstItem) {
-            manuallyRegisterIndex(logger, {
-              requestId: firstStep.requestId,
-              chainId: firstItem.data.chainId,
-              tx: jsonStringifyWithBigIntSanitization({
-                ...firstItem.data,
-                txHash
-              })
-            });
-          }
           try {
             await onTransactionConfirmed?.(txHash);
           } catch (e) {
@@ -355,42 +259,6 @@ async function executeRelayQuote({
     }
   });
 }
-async function manuallyRegisterIndex(logger, registerRequest) {
-  const logPrefix = "manuallyRegisterIndex";
-  const stringifiedRequest = JSON.stringify(registerRequest);
-  const url = `${MAINNET_RELAY_API2}/transactions/single`;
-  try {
-    logger.info(`${logPrefix}:onManuallyRegisterIndex`, {
-      params: stringifiedRequest
-    });
-    const response = await fetch(url, {
-      method: "POST",
-      body: JSON.stringify(registerRequest)
-    });
-    if (!response.ok) {
-      logger.error(`${logPrefix}:onManuallyRegisterIndexError`, {
-        message: "Error !response.ok - request to manually register index",
-        response: JSON.stringify(response),
-        params: stringifiedRequest
-      });
-      return;
-    }
-    const data = await response.json();
-    if (data.message !== "Success") {
-      logger.error(`${logPrefix}:onManuallyRegisterIndexError`, {
-        message: `Data.message is not of type Success - ${data.message}`,
-        response: JSON.stringify(response),
-        params: stringifiedRequest
-      });
-    }
-    return;
-  } catch (err) {
-    logger.error(`${logPrefix}:onManuallyRegisterIndexError`, {
-      message: `Error sending request to register index at ${url}: ${JSON.stringify(err?.message)}`,
-      params: stringifiedRequest
-    });
-  }
-}
 async function getRelayExecutionInfo(requestId, apiKey) {
   const url = `${MAINNET_RELAY_API2}/intents/status/v2?requestId=${requestId}`;
   const response = await fetch(url, {
@@ -475,6 +343,83 @@ function parseRelayFees({
 
 // src/price.ts
 import { MAINNET_RELAY_API as MAINNET_RELAY_API3 } from "@relayprotocol/relay-sdk";
+
+// src/utils.ts
+function convertFunToRelayTokenAddress(address, chainId) {
+  if (address.toLowerCase() === FUNKIT_NATIVE_TOKEN.toLowerCase()) {
+    switch (chainId) {
+      case FUN_HYPERCORE_CHAIN_ID_NUMBER:
+        return RELAY_NATIVE_TOKEN_HYPERCORE;
+      case RELAY_BITCOIN_CHAIN_ID_NUMBER:
+        return RELAY_NATIVE_TOKEN_BITCOIN;
+      // TODO: is it correct to assume chainId here is relay chain id?
+      case RELAY_SOLANA_CHAIN_ID_NUMBER:
+      case FUN_SOLANA_CHAIN_ID_NUMBER:
+        return RELAY_NATIVE_TOKEN_SOLANA;
+      case RELAY_LIGHTER_CHAIN_ID_NUMBER:
+        return RELAY_LIGHTER_USDC_PERPS;
+      default:
+        return RELAY_NATIVE_TOKEN;
+    }
+  }
+  if (RELAY_LIGHTER_CHAIN_ID_NUMBER === chainId) {
+    const relayAddress = RELAY_LIGHTER_FUN_ADDRESS_MAP[address.toLowerCase()];
+    if (relayAddress) {
+      return relayAddress;
+    }
+  }
+  return address;
+}
+function convertFunToRelayChainId(chainId) {
+  if (chainId === FUN_SOLANA_CHAIN_ID_NUMBER) {
+    return RELAY_SOLANA_CHAIN_ID_NUMBER;
+  }
+  return chainId;
+}
+function getRelayExecutionRefundState(info) {
+  switch (info.status) {
+    case "refund" /* REFUND */:
+      return "REFUNDED" /* REFUNDED */;
+    default:
+      return void 0;
+  }
+}
+function getRelayExecutionState(info) {
+  switch (info.status) {
+    case "success" /* SUCCESS */:
+      return "COMPLETED" /* COMPLETED */;
+    case "failure" /* FAILURE */:
+    case "refund" /* REFUND */:
+      return "CHECKOUT_ERROR" /* CHECKOUT_ERROR */;
+    default:
+      return "PENDING_RECEIVAL" /* PENDING_RECEIVAL */;
+  }
+}
+function isRelayExecutionTerminalStatus(info) {
+  return RELAY_TERMINAL_STATUSES.includes(info.status);
+}
+function indexBy(items, getKey) {
+  const indexedItems = {};
+  for (const item of items) {
+    const key = getKey(item);
+    if (!key) {
+      continue;
+    }
+    indexedItems[key] = item;
+  }
+  return indexedItems;
+}
+function filterNullishHeaders(params) {
+  const result = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (value != null) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/price.ts
 async function getRelayAssetPriceInfo({
   chainId,
   address,
@@ -833,7 +778,7 @@ import {
   encodeFunctionData as encodeFunctionData2,
   toFunctionSelector
 } from "viem";
-import { mainnet as mainnet2 } from "viem/chains";
+import { mainnet as mainnet3 } from "viem/chains";
 
 // src/dynamicRoutes/abi.ts
 var UNWRAP_AND_CALL_ABI = [
@@ -1276,7 +1221,7 @@ var ASSET_LOGO_SRCS = {
   IMX: "https://sdk-cdn.fun.xyz/images/imx.svg",
   INJ: "https://sdk-cdn.fun.xyz/images/inj.svg",
   LDO: "https://sdk-cdn.fun.xyz/images/ldo.svg",
-  LINK: "https://sdk-cdn.fun.xyz/images/link.svg",
+  LINK: "https://sdk-cdn.fun.xyz/images/link.png",
   LUCK: "https://sdk-cdn.fun.xyz/images/luck.png",
   MATIC: "https://sdk-cdn.fun.xyz/images/matic.svg",
   MFER: "https://sdk-cdn.fun.xyz/images/mfer.png",
@@ -1294,7 +1239,7 @@ var ASSET_LOGO_SRCS = {
   SOL: "https://sdk-cdn.fun.xyz/images/sol.svg",
   SUSDS: "https://sdk-cdn.fun.xyz/images/susds.svg",
   TYBG: "https://sdk-cdn.fun.xyz/images/tybg.png",
-  UNI: "https://sdk-cdn.fun.xyz/images/uni.svg",
+  UNI: "https://sdk-cdn.fun.xyz/images/uni.png",
   USDC: "https://sdk-cdn.fun.xyz/images/usdc.svg",
   "USDC.E": "https://sdk-cdn.fun.xyz/images/usdc.svg",
   USDE: "https://sdk-cdn.fun.xyz/images/usde.svg",
@@ -1335,7 +1280,8 @@ var ASSET_LOGO_SRCS = {
   MON: "https://sdk-cdn.fun.xyz/images/monad.svg",
   WMON: "https://sdk-cdn.fun.xyz/images/wmon.svg",
   AUSD: "https://sdk-cdn.fun.xyz/images/ausd.svg",
-  SUSHI: "https://sdk-cdn.fun.xyz/images/sushi.svg"
+  SUSHI: "https://sdk-cdn.fun.xyz/images/sushi.svg",
+  SKY: "https://sdk-cdn.fun.xyz/images/sky.svg"
 };
 
 // src/dynamicRoutes/consts.ts
@@ -1349,6 +1295,25 @@ var tokenAddresses = {
   },
   USDC: {
     [mainnet.id]: getAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48")
+  },
+  // LIT is currently unused
+  LIT: {
+    [mainnet.id]: getAddress("0x232CE3bd40fCd6f80f3d55A522d03f25Df784Ee2")
+  },
+  LINK: {
+    [mainnet.id]: getAddress("0x514910771AF9Ca656af840dff83E8264EcF986CA")
+  },
+  UNI: {
+    [mainnet.id]: getAddress("0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984")
+  },
+  AAVE: {
+    [mainnet.id]: getAddress("0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9")
+  },
+  SKY: {
+    [mainnet.id]: getAddress("0x56072C95FAA701256059aa122697B133aDEd9279")
+  },
+  LDO: {
+    [mainnet.id]: getAddress("0x5A98FcBEA516Cf06857215779Fd812CA3beF1B32")
   }
 };
 var UNWRAP_AND_CALL_ADDRESS = {
@@ -1363,6 +1328,8 @@ var LIGHTER_DEPOSIT_ADDRESS = getAddress(
 var MATCH_ALL_CONDITION = "*";
 
 // src/dynamicRoutes/utils.ts
+import { erc20Abi as ERC20_ABI } from "viem";
+import { mainnet as mainnet2 } from "viem/chains";
 var createPath = (config) => {
   return config;
 };
@@ -1445,6 +1412,35 @@ var initDynamicRouting = (dynamicRoutes, dynamicRoutingConfig) => {
   );
   return indexedDynamicRoutingConfig;
 };
+var MAX_APPROVAL = "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
+var getApprovalCalldata = ({
+  tokenAddress,
+  spenderAddress,
+  amount
+}) => {
+  return {
+    contractAbi: ERC20_ABI,
+    contractAddress: tokenAddress,
+    functionName: "approve",
+    functionArgs: [spenderAddress, amount]
+  };
+};
+var getResetApprovalCalldata = ({
+  tokenAddress,
+  spenderAddress
+}) => {
+  return getApprovalCalldata({
+    tokenAddress,
+    spenderAddress,
+    amount: "0"
+  });
+};
+var RESET_APPROVAL_TOKENS = [tokenAddresses.LDO[mainnet2.id]].map(
+  (address) => address.toLowerCase()
+);
+var shouldResetApproval = (tokenAddress) => {
+  return RESET_APPROVAL_TOKENS.includes(tokenAddress.toLowerCase());
+};
 
 // src/dynamicRoutes/lighter.ts
 var NATIVE_TOKEN = FUNKIT_NATIVE_TOKEN;
@@ -1453,14 +1449,31 @@ var RELAY_LIGHTER_ETH_SPOT_ADDRESS = "0x0000000000000000000000000000000000000001
 var RELAY_LIGHTER_USDC_PERPS_ADDRESS = "0x0000000000000000000000000000000000000000";
 var TICK_SIZE_FOR_ASSET_INDEX = {
   [3 /* USDC */]: BigInt(1),
-  [1 /* ETH */]: BigInt(10 ** 10)
+  [1 /* ETH */]: BigInt(10 ** 10),
+  [2 /* LIT */]: BigInt(10 ** 10),
+  [5 /* LINK */]: BigInt(10 ** 10),
+  [6 /* UNI */]: BigInt(10 ** 10),
+  [7 /* AAVE */]: BigInt(10 ** 10),
+  [8 /* SKY */]: BigInt(10 ** 10),
+  [9 /* LDO */]: BigInt(10 ** 10)
 };
 var DEPOSIT_TOKEN_FOR_ASSET_INDEX = {
-  [3 /* USDC */]: tokenAddresses.USDC[mainnet2.id],
-  [1 /* ETH */]: NATIVE_TOKEN
+  [3 /* USDC */]: tokenAddresses.USDC[mainnet3.id],
+  [1 /* ETH */]: NATIVE_TOKEN,
+  [2 /* LIT */]: tokenAddresses.LIT[mainnet3.id],
+  [5 /* LINK */]: tokenAddresses.LINK[mainnet3.id],
+  [6 /* UNI */]: tokenAddresses.UNI[mainnet3.id],
+  [7 /* AAVE */]: tokenAddresses.AAVE[mainnet3.id],
+  [8 /* SKY */]: tokenAddresses.SKY[mainnet3.id],
+  [9 /* LDO */]: tokenAddresses.LDO[mainnet3.id]
 };
 var USDC_PERPS_SYMBOL = "USDC (Perps)";
 var ETH_SPOT_SYMBOL = "ETH (Spot)";
+var LINK_SPOT_SYMBOL = "LINK (Spot)";
+var UNI_SPOT_SYMBOL = "UNI (Spot)";
+var AAVE_SPOT_SYMBOL = "AAVE (Spot)";
+var SKY_SPOT_SYMBOL = "SKY (Spot)";
+var LDO_SPOT_SYMBOL = "LDO (Spot)";
 var generateLighterMainnetDepositActions = ({
   address,
   assetIndex,
@@ -1503,22 +1516,18 @@ var generateLighterMainnetDepositActions = ({
     });
     return [
       // Step 1: Approve WETH to UnwrapWETHAndCall
-      {
-        contractAbi: erc20Abi,
-        contractAddress: tokenAddresses.WETH[mainnet2.id],
-        functionName: "approve",
-        functionArgs: [
-          UNWRAP_AND_CALL_ADDRESS[mainnet2.id],
-          "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
-        ]
-      },
+      getApprovalCalldata({
+        tokenAddress: tokenAddresses.WETH[mainnet3.id],
+        spenderAddress: UNWRAP_AND_CALL_ADDRESS[mainnet3.id],
+        amount: MAX_APPROVAL
+      }),
       // Step 2: UnwrapWETHAndCall pulls WETH, unwraps to ETH, sends to VaultWrapper, calls deposit
       {
         contractAbi: UNWRAP_AND_CALL_ABI,
-        contractAddress: UNWRAP_AND_CALL_ADDRESS[mainnet2.id],
+        contractAddress: UNWRAP_AND_CALL_ADDRESS[mainnet3.id],
         functionName: "unwrapAndCall",
         functionArgs: [
-          VAULT_DEPOSITOR_ADDRESS[mainnet2.id],
+          VAULT_DEPOSITOR_ADDRESS[mainnet3.id],
           // target (VaultWrapper)
           vaultWrapperCalldata
           // VaultWrapper.deposit() calldata
@@ -1526,52 +1535,53 @@ var generateLighterMainnetDepositActions = ({
       }
     ];
   }
-  if (depositToken === tokenAddresses.USDC[mainnet2.id]) {
-    return [
-      // Step 1: Approve USDC to VaultDepositor
-      {
-        contractAbi: erc20Abi,
-        contractAddress: tokenAddresses.USDC[mainnet2.id],
-        functionName: "approve",
-        functionArgs: [
-          VAULT_DEPOSITOR_ADDRESS[mainnet2.id],
-          "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
-          // Max approval
-        ]
-      },
-      // Step 2: VaultDepositor pulls USDC and calls Lighter deposit
-      {
-        contractAbi: VAULT_DEPOSITOR_ABI,
-        contractAddress: VAULT_DEPOSITOR_ADDRESS[mainnet2.id],
-        functionName: "depositWithTick",
-        functionArgs: [
-          tokenAddresses.USDC[mainnet2.id],
-          // token (USDC)
-          LIGHTER_DEPOSIT_ADDRESS,
-          // vault (Lighter deposit contract)
-          lighterDepositCalldata,
-          // callData
-          0n,
-          // minAmountOut
-          tickSize,
-          // tickSize
-          dustRecipient
-          // dustRecipient
-        ]
-      }
-    ];
-  }
+  const resetApprovalNeeded = shouldResetApproval(depositToken);
+  return [
+    // Special handling of LDO token as it requires approval reset before approval can be set to a new value due to non-standard implementation of the approve function.
+    ...resetApprovalNeeded ? [
+      getResetApprovalCalldata({
+        tokenAddress: depositToken,
+        spenderAddress: VAULT_DEPOSITOR_ADDRESS[mainnet3.id]
+      })
+    ] : [],
+    // Step 1: Approve deposit token to VaultDepositor
+    getApprovalCalldata({
+      tokenAddress: depositToken,
+      spenderAddress: VAULT_DEPOSITOR_ADDRESS[mainnet3.id],
+      amount: MAX_APPROVAL
+    }),
+    // Step 2: VaultDepositor pulls deposit token and calls Lighter deposit
+    {
+      contractAbi: VAULT_DEPOSITOR_ABI,
+      contractAddress: VAULT_DEPOSITOR_ADDRESS[mainnet3.id],
+      functionName: "depositWithTick",
+      functionArgs: [
+        depositToken,
+        // token (deposit token)
+        LIGHTER_DEPOSIT_ADDRESS,
+        // vault (Lighter deposit contract)
+        lighterDepositCalldata,
+        // callData
+        0n,
+        // minAmountOut
+        tickSize,
+        // tickSize
+        dustRecipient
+        // dustRecipient
+      ]
+    }
+  ];
 };
 var LIGHTER_USDC_PERPS_FUN_MAINNET_DEPOSIT = createPath({
-  targetChain: mainnet2.id.toString(),
-  targetAsset: tokenAddresses.USDC[mainnet2.id],
+  targetChain: mainnet3.id.toString(),
+  targetAsset: tokenAddresses.USDC[mainnet3.id],
   targetAssetTicker: USDC_PERPS_SYMBOL,
   iconSrc: ASSET_LOGO_SRCS.USDC,
   generateActionsParams: (address) => async (_finalTargetAssetAmount, outputConfig) => {
     if (!outputConfig) {
       return [];
     }
-    if (outputConfig.targetChain !== mainnet2.id.toString()) {
+    if (outputConfig.targetChain !== mainnet3.id.toString()) {
       return [];
     }
     return generateLighterMainnetDepositActions({
@@ -1582,15 +1592,15 @@ var LIGHTER_USDC_PERPS_FUN_MAINNET_DEPOSIT = createPath({
   }
 });
 var LIGHTER_ETH_SPOT_FUN_MAINNET_DEPOSIT = createPath({
-  targetChain: mainnet2.id.toString(),
-  targetAsset: tokenAddresses.WETH[mainnet2.id],
+  targetChain: mainnet3.id.toString(),
+  targetAsset: tokenAddresses.WETH[mainnet3.id],
   targetAssetTicker: ETH_SPOT_SYMBOL,
   iconSrc: ASSET_LOGO_SRCS.ETH,
   generateActionsParams: (address) => async (_finalTargetAssetAmount, outputConfig) => {
     if (!outputConfig) {
       return [];
     }
-    if (outputConfig.targetChain !== mainnet2.id.toString()) {
+    if (outputConfig.targetChain !== mainnet3.id.toString()) {
       return [];
     }
     return generateLighterMainnetDepositActions({
@@ -1600,6 +1610,101 @@ var LIGHTER_ETH_SPOT_FUN_MAINNET_DEPOSIT = createPath({
     });
   }
 });
+var LIGHTER_LINK_SPOT_FUN_MAINNET_DEPOSIT = createPath({
+  targetChain: mainnet3.id.toString(),
+  targetAsset: tokenAddresses.LINK[mainnet3.id],
+  targetAssetTicker: LINK_SPOT_SYMBOL,
+  iconSrc: ASSET_LOGO_SRCS.LINK,
+  generateActionsParams: (address) => async (_finalTargetAssetAmount, outputConfig) => {
+    if (!outputConfig) {
+      return [];
+    }
+    if (outputConfig.targetChain !== mainnet3.id.toString()) {
+      return [];
+    }
+    return generateLighterMainnetDepositActions({
+      address,
+      assetIndex: 5 /* LINK */,
+      routeType: 1 /* Spot */
+    });
+  }
+});
+var LIGHTER_SKY_SPOT_FUN_MAINNET_DEPOSIT = createPath({
+  targetChain: mainnet3.id.toString(),
+  targetAsset: tokenAddresses.SKY[mainnet3.id],
+  targetAssetTicker: SKY_SPOT_SYMBOL,
+  iconSrc: ASSET_LOGO_SRCS.SKY,
+  generateActionsParams: (address) => async (_finalTargetAssetAmount, outputConfig) => {
+    if (!outputConfig) {
+      return [];
+    }
+    if (outputConfig.targetChain !== mainnet3.id.toString()) {
+      return [];
+    }
+    return generateLighterMainnetDepositActions({
+      address,
+      assetIndex: 8 /* SKY */,
+      routeType: 1 /* Spot */
+    });
+  }
+});
+var LIGHTER_UNI_SPOT_FUN_MAINNET_DEPOSIT = createPath({
+  targetChain: mainnet3.id.toString(),
+  targetAsset: tokenAddresses.UNI[mainnet3.id],
+  targetAssetTicker: UNI_SPOT_SYMBOL,
+  iconSrc: ASSET_LOGO_SRCS.UNI,
+  generateActionsParams: (address) => async (_finalTargetAssetAmount, outputConfig) => {
+    if (!outputConfig) {
+      return [];
+    }
+    if (outputConfig.targetChain !== mainnet3.id.toString()) {
+      return [];
+    }
+    return generateLighterMainnetDepositActions({
+      address,
+      assetIndex: 6 /* UNI */,
+      routeType: 1 /* Spot */
+    });
+  }
+});
+var LIGHTER_AAVE_SPOT_FUN_MAINNET_DEPOSIT = createPath({
+  targetChain: mainnet3.id.toString(),
+  targetAsset: tokenAddresses.AAVE[mainnet3.id],
+  targetAssetTicker: AAVE_SPOT_SYMBOL,
+  iconSrc: ASSET_LOGO_SRCS.AAVE,
+  generateActionsParams: (address) => async (_finalTargetAssetAmount, outputConfig) => {
+    if (!outputConfig) {
+      return [];
+    }
+    if (outputConfig.targetChain !== mainnet3.id.toString()) {
+      return [];
+    }
+    return generateLighterMainnetDepositActions({
+      address,
+      assetIndex: 7 /* AAVE */,
+      routeType: 1 /* Spot */
+    });
+  }
+});
+var LIGHTER_LDO_SPOT_FUN_MAINNET_DEPOSIT = createPath({
+  targetChain: mainnet3.id.toString(),
+  targetAsset: tokenAddresses.LDO[mainnet3.id],
+  targetAssetTicker: LDO_SPOT_SYMBOL,
+  iconSrc: ASSET_LOGO_SRCS.LDO,
+  generateActionsParams: (address) => async (_finalTargetAssetAmount, outputConfig) => {
+    if (!outputConfig) {
+      return [];
+    }
+    if (outputConfig.targetChain !== mainnet3.id.toString()) {
+      return [];
+    }
+    return generateLighterMainnetDepositActions({
+      address,
+      assetIndex: 9 /* LDO */,
+      routeType: 1 /* Spot */
+    });
+  }
+});
 var LIGHTER_DYNAMIC_ROUTES = [
   createRoute({
     id: "LIGHTER_ETH_SPOT",
@@ -1642,6 +1747,37 @@ var LIGHTER_DYNAMIC_ROUTES = [
     paths: {
       FUN_MAINNET_DEPOSIT: LIGHTER_ETH_SPOT_FUN_MAINNET_DEPOSIT
     }
+  }),
+  // LINK, UNI, AAVE, SKY, LDO tokens
+  createRoute({
+    id: "LIGHTER_LINK_SPOT_NEW_USER",
+    paths: {
+      FUN_MAINNET_DEPOSIT: LIGHTER_LINK_SPOT_FUN_MAINNET_DEPOSIT
+    }
+  }),
+  createRoute({
+    id: "LIGHTER_SKY_SPOT_NEW_USER",
+    paths: {
+      FUN_MAINNET_DEPOSIT: LIGHTER_SKY_SPOT_FUN_MAINNET_DEPOSIT
+    }
+  }),
+  createRoute({
+    id: "LIGHTER_UNI_SPOT_NEW_USER",
+    paths: {
+      FUN_MAINNET_DEPOSIT: LIGHTER_UNI_SPOT_FUN_MAINNET_DEPOSIT
+    }
+  }),
+  createRoute({
+    id: "LIGHTER_AAVE_SPOT_NEW_USER",
+    paths: {
+      FUN_MAINNET_DEPOSIT: LIGHTER_AAVE_SPOT_FUN_MAINNET_DEPOSIT
+    }
+  }),
+  createRoute({
+    id: "LIGHTER_LDO_SPOT_NEW_USER",
+    paths: {
+      FUN_MAINNET_DEPOSIT: LIGHTER_LDO_SPOT_FUN_MAINNET_DEPOSIT
+    }
   })
 ];
 
@@ -1679,6 +1815,7 @@ export {
   initDynamicRouting,
   initializeRelayClient,
   isRelayExecutionTerminalStatus,
-  parseRelayFees
+  parseRelayFees,
+  shouldResetApproval
 };
 //# sourceMappingURL=index.mjs.map