@pear-protocol/exchanges-sdk 0.8.0 → 0.9.1

package/dist/client/lighter/rest.js

@@ -66,11 +66,7 @@ async function fetchDepositHistory(params, demo = false) {
     l1_address: params.l1Address,
     filter: "all"
   });
-  const response = await proxyFetch(`${getLighterBaseUrl(demo)}/api/v1/deposit/history?${query.toString()}`, {
-    headers: {
-      authorization: params.authToken
-    }
-  });
+  const response = await authenticatedLighterFetch(`${getLighterBaseUrl(demo)}/api/v1/deposit/history?${query.toString()}`, params.authToken);
   const data = await readLighterResponse(response, "/deposit/history");
   const deposits = [];
   for (const deposit of data.deposits ?? []) {
@@ -139,18 +135,31 @@ async function fetchAccountsByL1Address(l1Address, demo = false) {
   };
 }
 __name(fetchAccountsByL1Address, "fetchAccountsByL1Address");
-async function fetchAccount(accountIndex, demo = false) {
-  const response = await proxyFetch(`${getLighterBaseUrl(demo)}/api/v1/account?by=index&value=${accountIndex}`);
+async function fetchAccount(accountIndex, authToken, demo = false) {
+  const response = await authenticatedLighterFetch(`${getLighterBaseUrl(demo)}/api/v1/account?by=index&value=${accountIndex}`, authToken);
   return readLighterResponse(response, "/account");
 }
 __name(fetchAccount, "fetchAccount");
-async function fetchAccountMetadata(accountIndex, authToken, demo = false) {
-  const response = await proxyFetch(`${getLighterBaseUrl(demo)}/api/v1/accountMetadata?by=index&value=${accountIndex}`, {
+async function fetchPublicAccount(accountIndex, demo = false) {
+  const response = await proxyFetch(`${getLighterBaseUrl(demo)}/api/v1/account?by=index&value=${accountIndex}`);
+  return readLighterResponse(response, "/account");
+}
+__name(fetchPublicAccount, "fetchPublicAccount");
+async function fetchAccountLimits(accountIndex, authToken, demo = false) {
+  const response = await proxyFetch(`${getLighterBaseUrl(demo)}/api/v1/accountLimits?account_index=${accountIndex}`, {
     headers: {
-      accept: "application/json",
       authorization: authToken
     }
   });
+  return readLighterResponse(response, "/accountLimits");
+}
+__name(fetchAccountLimits, "fetchAccountLimits");
+async function fetchAccountMetadata(accountIndex, authToken, demo = false) {
+  const response = await authenticatedLighterFetch(`${getLighterBaseUrl(demo)}/api/v1/accountMetadata?by=index&value=${accountIndex}`, authToken, {
+    headers: {
+      accept: "application/json"
+    }
+  });
   const data = await readLighterResponse(response, "/accountMetadata");
   const matchesAccount = data.account_metadatas?.some((metadata) => metadata.account_index === accountIndex);
   if (!matchesAccount) {
@@ -158,8 +167,8 @@ async function fetchAccountMetadata(accountIndex, authToken, demo = false) {
   }
 }
 __name(fetchAccountMetadata, "fetchAccountMetadata");
-async function fetchOrderBookDetails(demo = false) {
-  const response = await proxyFetch(`${getLighterBaseUrl(demo)}/api/v1/orderBookDetails`);
+async function fetchOrderBookDetails(authToken, demo = false) {
+  const response = await authenticatedLighterFetch(`${getLighterBaseUrl(demo)}/api/v1/orderBookDetails`, authToken);
   const data = await readLighterResponse(response, "/orderBookDetails");
   return {
     perp: data.order_book_details ?? [],
@@ -167,6 +176,15 @@ async function fetchOrderBookDetails(demo = false) {
   };
 }
 __name(fetchOrderBookDetails, "fetchOrderBookDetails");
+async function fetchPublicOrderBookDetails(demo = false) {
+  const response = await proxyFetch(`${getLighterBaseUrl(demo)}/api/v1/orderBookDetails`);
+  const data = await readLighterResponse(response, "/orderBookDetails");
+  return {
+    perp: data.order_book_details ?? [],
+    spot: data.spot_order_book_details ?? []
+  };
+}
+__name(fetchPublicOrderBookDetails, "fetchPublicOrderBookDetails");
 async function fetchAssetDetails(demo) {
   const response = await proxyFetch(`${getLighterBaseUrl(demo)}/api/v1/assetDetails`);
   const data = await readLighterResponse(response, "/assetDetails");
@@ -192,11 +210,7 @@ async function fetchTradesSince(accountIndex, authToken, since, demo = false) {
         cursor
       } : {}
     });
-    const response = await proxyFetch(`${getLighterBaseUrl(demo)}/api/v1/trades?${params.toString()}`, {
-      headers: {
-        authorization: authToken
-      }
-    });
+    const response = await authenticatedLighterFetch(`${getLighterBaseUrl(demo)}/api/v1/trades?${params.toString()}`, authToken);
     const data = await readLighterResponse(response, "/trades");
     const page = data.trades ?? [];
     results.push(...page.filter((trade) => trade.timestamp >= since.getTime()));
@@ -229,11 +243,7 @@ async function fetchPositionFundingSince(accountIndex, authToken, since, demo =
         cursor
       } : {}
     });
-    const response = await proxyFetch(`${getLighterBaseUrl(demo)}/api/v1/positionFunding?${params.toString()}`, {
-      headers: {
-        authorization: authToken
-      }
-    });
+    const response = await authenticatedLighterFetch(`${getLighterBaseUrl(demo)}/api/v1/positionFunding?${params.toString()}`, authToken);
     const data = await readLighterResponse(response, "/positionFunding");
     for (const funding of data.position_fundings ?? []) {
       if (funding.timestamp >= sinceSeconds) {
@@ -249,6 +259,15 @@ async function fetchPositionFundingSince(accountIndex, authToken, since, demo =
   return Array.from(results.values());
 }
 __name(fetchPositionFundingSince, "fetchPositionFundingSince");
+async function authenticatedLighterFetch(url, authToken, init) {
+  const headers = new Headers(init?.headers);
+  headers.set("authorization", authToken);
+  return proxyFetch(url, {
+    ...init,
+    headers
+  });
+}
+__name(authenticatedLighterFetch, "authenticatedLighterFetch");
 async function fetchDepositIntentWithRetry(url, init) {
   for (let attempt = 1; attempt <= INTENT_REQUEST_ATTEMPTS; attempt += 1) {
     const response = await proxyFetch(url, init);
@@ -283,4 +302,4 @@ async function readLighterResponse(response, endpoint, acceptedCodes = [
 }
 __name(readLighterResponse, "readLighterResponse");
 
-export { createCctpDepositIntentAddress, fetchAccount, fetchAccountMetadata, fetchAccountsByL1Address, fetchApiKeys, fetchAssetDetails, fetchDepositHistory, fetchDepositNetworks, fetchOrderBookDetails, fetchPositionFundingSince, fetchTradesSince };
+export { createCctpDepositIntentAddress, fetchAccount, fetchAccountLimits, fetchAccountMetadata, fetchAccountsByL1Address, fetchApiKeys, fetchAssetDetails, fetchDepositHistory, fetchDepositNetworks, fetchOrderBookDetails, fetchPositionFundingSince, fetchPublicAccount, fetchPublicOrderBookDetails, fetchTradesSince };

package/dist/client/lighter/ws.js

@@ -23,6 +23,14 @@ class LighterWs extends BaseWs {
       type: "ping"
     };
   }
+  /** Subscribes to one account channel with the authentication Lighter requires. */
+  subscribe(channel, authToken) {
+    this.send({
+      type: "subscribe",
+      channel,
+      auth: authToken
+    });
+  }
 }
 
 export { LighterWs };

package/dist/helper/lighter/asset-decimals.helper.js

@@ -0,0 +1,25 @@
+import { fetchAssetDetails } from '../../client/lighter/rest';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+async function resolveAssetDecimals(assetId, field, suppliedDecimals, demo) {
+  if (suppliedDecimals !== void 0) {
+    return validateDecimals(suppliedDecimals, field);
+  }
+  const assets = await fetchAssetDetails(demo);
+  const asset = assets.find((candidate) => candidate.asset_id === assetId);
+  if (!asset) {
+    throw new Error(`Lighter asset ${assetId} was not returned by assetDetails`);
+  }
+  return validateDecimals(asset[field], `assetDetails.${field}`);
+}
+__name(resolveAssetDecimals, "resolveAssetDecimals");
+function validateDecimals(decimals, source) {
+  if (!Number.isSafeInteger(decimals) || decimals < 0 || decimals > 255) {
+    throw new Error(`Invalid ${source} decimals: ${decimals}`);
+  }
+  return decimals;
+}
+__name(validateDecimals, "validateDecimals");
+
+export { resolveAssetDecimals };

package/dist/helper/lighter/cctp-deposit.helper.js

@@ -2,24 +2,19 @@ import { isAddress } from 'viem';
 import { fetchDepositNetworks, createCctpDepositIntentAddress, fetchAccountsByL1Address, fetchDepositHistory } from '../../client/lighter/rest';
 import { parseUsdcAmount } from '../subaccount.helper';
 import { retrieveLighterAuthToken } from './auth-token.helper';
-import { getLighterCctpUsdcAddress, writeUsdcTransfer } from './ethereum/usdc.helper';
-import { readOnboardingStatus } from './onboarding.helper';
+import { assertOwnerWallet, readUsdcAmountSyntaxError, readDepositMinimumError, formatUsdcUnits, emitProgress, watchAccountRegistration, waitForDepositPoll, SETTLEMENT_WATCH_LIMIT_MS } from './deposit-settlement.helper';
+import { getLighterNativeUsdcAddress, writeUsdcTransfer } from './ethereum/usdc.helper';
 import { MIN_LIGHTER_CCTP_DEPOSIT_USDC } from './types';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-const DEPOSIT_POLL_INTERVAL_MS = 5e3;
 const EXTERNAL_INTENT_LIFETIME_MS = 9 * 60 * 1e3;
-const REGISTRATION_WATCH_LIMIT_MS = 60 * 60 * 1e3;
-const USDC_AMOUNT_PATTERN = /^\d+(?:\.\d{1,6})?$/;
-const MINIMUM_LABEL = `Minimum deposit: $${MIN_LIGHTER_CCTP_DEPOSIT_USDC} USDC`;
-const MINIMUM_UNITS = parseUsdcAmount(MIN_LIGHTER_CCTP_DEPOSIT_USDC);
 async function listCctpDepositNetworks(demo) {
   assertCctpEnvironment(demo);
   return fetchDepositNetworks(demo);
 }
 __name(listCctpDepositNetworks, "listCctpDepositNetworks");
-async function createExternalCctpDepositIntent(params, demo) {
+async function createCctpDepositAddress(params, demo) {
   await validateIntentRoute(params, demo);
   const intentAddress = await createCctpDepositIntentAddress({
     chainId: params.chainId,
@@ -28,23 +23,28 @@ async function createExternalCctpDepositIntent(params, demo) {
     external: true
   }, demo);
   return {
+    route: "cctp",
     intentAddress,
     expiresAt: Date.now() + EXTERNAL_INTENT_LIFETIME_MS
   };
 }
-__name(createExternalCctpDepositIntent, "createExternalCctpDepositIntent");
+__name(createCctpDepositAddress, "createCctpDepositAddress");
 async function depositUsdcViaCctp(sdk, params, demo) {
   assertCctpEnvironment(demo);
   assertOwnerWallet(params.ownerAddress, params.connectedAddress);
-  const usdcAddress = getLighterCctpUsdcAddress(params.chainId);
+  const usdcAddress = getLighterNativeUsdcAddress(params.chainId);
   if (!usdcAddress) {
     throw new Error(`Lighter CCTP chain ID ${params.chainId} has no known native USDC token.`);
   }
-  const amountError = readCctpDepositAmountError(params.amount);
-  if (amountError) {
-    throw new Error(amountError);
+  const syntaxError = readUsdcAmountSyntaxError(params.amount);
+  if (syntaxError) {
+    throw new Error(syntaxError);
   }
   const units = parseUsdcAmount(params.amount);
+  const minimumError = readDepositMinimumError(units, MIN_LIGHTER_CCTP_DEPOSIT_USDC);
+  if (minimumError) {
+    throw new Error(minimumError);
+  }
   const balance = await params.wallet.readUsdcBalance(params.chainId, params.ownerAddress);
   if (units > balance) {
     throw new Error(`Your wallet holds ${formatUsdcUnits(balance)} USDC.`);
@@ -82,22 +82,12 @@ async function depositUsdcViaCctp(sdk, params, demo) {
   });
   await followDepositSettlement(params, txHash, sdk, demo);
   return {
+    route: "cctp",
     txHash,
     intentAddress
   };
 }
 __name(depositUsdcViaCctp, "depositUsdcViaCctp");
-function readCctpDepositAmountError(amount) {
-  if (!USDC_AMOUNT_PATTERN.test(amount)) {
-    return "Enter a USDC amount with up to six decimal places.";
-  }
-  const units = parseUsdcAmount(amount);
-  if (units < MINIMUM_UNITS) {
-    return `${MINIMUM_LABEL}.`;
-  }
-  return void 0;
-}
-__name(readCctpDepositAmountError, "readCctpDepositAmountError");
 async function validateIntentRoute(params, demo) {
   assertCctpEnvironment(demo);
   if (!isAddress(params.ownerAddress)) {
@@ -110,12 +100,6 @@ async function validateIntentRoute(params, demo) {
   }
 }
 __name(validateIntentRoute, "validateIntentRoute");
-function assertOwnerWallet(ownerAddress, connectedAddress) {
-  if (connectedAddress?.toLowerCase() !== ownerAddress.toLowerCase()) {
-    throw new Error(`Connect the Lighter owner wallet ${ownerAddress} and try again.`);
-  }
-}
-__name(assertOwnerWallet, "assertOwnerWallet");
 function assertCctpEnvironment(demo) {
   if (demo) {
     throw new Error("Lighter demo CCTP deposits are disabled because safe testnet funding is not documented");
@@ -141,11 +125,11 @@ async function followDepositSettlement(params, txHash, sdk, demo) {
         });
         return;
       }
-      await watchCctpDeposit(params.ownerAddress, txHash, watch, params.onProgress, sdk, demo);
+      await watchCctpDeposit(params.ownerAddress, txHash, watch, params.onProgress, sdk, demo, params.settlementTimeoutMs);
       return;
     }
     case "account-registration": {
-      await watchAccountRegistration(params.ownerAddress, txHash, params.onProgress, params.signal, demo);
+      await watchAccountRegistration(params.ownerAddress, txHash, params.onProgress, params.signal, demo, params.settlementTimeoutMs);
       return;
     }
   }
@@ -166,12 +150,20 @@ async function resolveDepositWatch(ownerAddress, settlement, signal, demo) {
   };
 }
 __name(resolveDepositWatch, "resolveDepositWatch");
-async function watchCctpDeposit(ownerAddress, txHash, watch, onProgress, sdk, demo) {
+async function watchCctpDeposit(ownerAddress, txHash, watch, onProgress, sdk, demo, timeoutMs) {
+  const deadline = Date.now() + (timeoutMs ?? SETTLEMENT_WATCH_LIMIT_MS);
   while (!watch.signal?.aborted) {
     await waitForDepositPoll(watch.signal);
     if (watch.signal?.aborted) {
       return;
     }
+    if (Date.now() >= deadline) {
+      emitProgress(onProgress, watch.signal, {
+        state: "unsettled",
+        txHash
+      });
+      return;
+    }
     let deposits;
     try {
       const authToken = await retrieveLighterAuthToken(sdk, watch, demo);
@@ -202,7 +194,10 @@ async function watchCctpDeposit(ownerAddress, txHash, watch, onProgress, sdk, de
         emitProgress(onProgress, watch.signal, {
           state: "credited",
           txHash,
-          deposit
+          credit: {
+            source: "lighter-history",
+            deposit
+          }
         });
         return;
       case "failed":
@@ -223,75 +218,5 @@ async function watchCctpDeposit(ownerAddress, txHash, watch, onProgress, sdk, de
   }
 }
 __name(watchCctpDeposit, "watchCctpDeposit");
-async function watchAccountRegistration(ownerAddress, txHash, onProgress, signal, demo) {
-  const deadline = Date.now() + REGISTRATION_WATCH_LIMIT_MS;
-  while (!signal?.aborted) {
-    await waitForDepositPoll(signal);
-    if (signal?.aborted) {
-      return;
-    }
-    if (Date.now() >= deadline) {
-      emitProgress(onProgress, signal, {
-        state: "unsettled",
-        txHash
-      });
-      return;
-    }
-    let status;
-    try {
-      status = await readOnboardingStatus(ownerAddress, demo);
-    } catch {
-      continue;
-    }
-    switch (status.step) {
-      case "deposit-required":
-        emitProgress(onProgress, signal, {
-          state: "bridging",
-          txHash
-        });
-        break;
-      case "account-ready":
-        emitProgress(onProgress, signal, {
-          state: "registered",
-          txHash,
-          mainAccountIndex: status.mainAccountIndex,
-          subAccountIndexes: status.subAccountIndexes
-        });
-        return;
-    }
-  }
-}
-__name(watchAccountRegistration, "watchAccountRegistration");
-function emitProgress(onProgress, signal, progress) {
-  if (signal?.aborted) {
-    return;
-  }
-  onProgress(progress);
-}
-__name(emitProgress, "emitProgress");
-async function waitForDepositPoll(signal) {
-  await new Promise((resolve) => {
-    let timeout;
-    const stopWaiting = /* @__PURE__ */ __name(() => {
-      clearTimeout(timeout);
-      resolve();
-    }, "stopWaiting");
-    timeout = setTimeout(() => {
-      signal?.removeEventListener("abort", stopWaiting);
-      resolve();
-    }, DEPOSIT_POLL_INTERVAL_MS);
-    signal?.addEventListener("abort", stopWaiting, {
-      once: true
-    });
-  });
-}
-__name(waitForDepositPoll, "waitForDepositPoll");
-function formatUsdcUnits(units) {
-  const value = units.toString().padStart(7, "0");
-  const whole = value.slice(0, -6);
-  const fraction = value.slice(-6).replace(/0+$/, "");
-  return fraction ? `${whole}.${fraction}` : whole;
-}
-__name(formatUsdcUnits, "formatUsdcUnits");
 
-export { createExternalCctpDepositIntent, depositUsdcViaCctp, listCctpDepositNetworks };
+export { createCctpDepositAddress, depositUsdcViaCctp, listCctpDepositNetworks };

package/dist/helper/lighter/deposit-settlement.helper.js

@@ -0,0 +1,100 @@
+import { parseUsdcAmount } from '../subaccount.helper';
+import { readOnboardingStatus } from './onboarding.helper';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const DEPOSIT_POLL_INTERVAL_MS = 5e3;
+const SETTLEMENT_WATCH_LIMIT_MS = 60 * 60 * 1e3;
+const USDC_AMOUNT_PATTERN = /^\d+(?:\.\d{1,6})?$/;
+function readUsdcAmountSyntaxError(amount) {
+  if (!USDC_AMOUNT_PATTERN.test(amount)) {
+    return "Enter a USDC amount with up to six decimal places.";
+  }
+  return void 0;
+}
+__name(readUsdcAmountSyntaxError, "readUsdcAmountSyntaxError");
+function readDepositMinimumError(units, minimumUsd) {
+  if (units < parseUsdcAmount(minimumUsd)) {
+    return `Minimum deposit: $${minimumUsd} USDC.`;
+  }
+  return void 0;
+}
+__name(readDepositMinimumError, "readDepositMinimumError");
+function assertOwnerWallet(ownerAddress, connectedAddress) {
+  if (connectedAddress?.toLowerCase() !== ownerAddress.toLowerCase()) {
+    throw new Error(`Connect the Lighter owner wallet ${ownerAddress} and try again.`);
+  }
+}
+__name(assertOwnerWallet, "assertOwnerWallet");
+async function watchAccountRegistration(ownerAddress, txHash, onProgress, signal, demo, timeoutMs) {
+  const deadline = Date.now() + (timeoutMs ?? SETTLEMENT_WATCH_LIMIT_MS);
+  while (!signal?.aborted) {
+    await waitForDepositPoll(signal);
+    if (signal?.aborted) {
+      return;
+    }
+    if (Date.now() >= deadline) {
+      emitProgress(onProgress, signal, {
+        state: "unsettled",
+        txHash
+      });
+      return;
+    }
+    let status;
+    try {
+      status = await readOnboardingStatus(ownerAddress, demo);
+    } catch {
+      continue;
+    }
+    switch (status.step) {
+      case "deposit-required":
+        emitProgress(onProgress, signal, {
+          state: "bridging",
+          txHash
+        });
+        break;
+      case "account-ready":
+        emitProgress(onProgress, signal, {
+          state: "registered",
+          txHash,
+          mainAccountIndex: status.mainAccountIndex,
+          subAccountIndexes: status.subAccountIndexes
+        });
+        return;
+    }
+  }
+}
+__name(watchAccountRegistration, "watchAccountRegistration");
+function emitProgress(onProgress, signal, progress) {
+  if (signal?.aborted) {
+    return;
+  }
+  onProgress(progress);
+}
+__name(emitProgress, "emitProgress");
+async function waitForDepositPoll(signal) {
+  await new Promise((resolve) => {
+    let timeout;
+    const stopWaiting = /* @__PURE__ */ __name(() => {
+      clearTimeout(timeout);
+      resolve();
+    }, "stopWaiting");
+    timeout = setTimeout(() => {
+      signal?.removeEventListener("abort", stopWaiting);
+      resolve();
+    }, DEPOSIT_POLL_INTERVAL_MS);
+    signal?.addEventListener("abort", stopWaiting, {
+      once: true
+    });
+  });
+}
+__name(waitForDepositPoll, "waitForDepositPoll");
+function formatUsdcUnits(units) {
+  const value = units.toString().padStart(7, "0");
+  const whole = value.slice(0, -6);
+  const fraction = value.slice(-6).replace(/0+$/, "");
+  return fraction ? `${whole}.${fraction}` : whole;
+}
+__name(formatUsdcUnits, "formatUsdcUnits");
+
+export { DEPOSIT_POLL_INTERVAL_MS, SETTLEMENT_WATCH_LIMIT_MS, assertOwnerWallet, emitProgress, formatUsdcUnits, readDepositMinimumError, readUsdcAmountSyntaxError, waitForDepositPoll, watchAccountRegistration };

package/dist/helper/lighter/deposit.helper.js

@@ -0,0 +1,28 @@
+import { depositUsdcViaCctp, createCctpDepositAddress } from './cctp-deposit.helper';
+import { depositViaEthereumGateway } from './ethereum-deposit.helper';
+import { depositUsdcViaFunxyz, createFunxyzDepositAddress } from './funxyz-deposit.helper';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+async function depositThroughRoute(sdk, params, demo) {
+  switch (params.route) {
+    case "ethereum":
+      return depositViaEthereumGateway(params, demo);
+    case "cctp":
+      return depositUsdcViaCctp(sdk, params, demo);
+    case "funxyz":
+      return depositUsdcViaFunxyz(sdk, params, demo);
+  }
+}
+__name(depositThroughRoute, "depositThroughRoute");
+async function createDepositAddressForRoute(sdk, params, demo) {
+  switch (params.route) {
+    case "cctp":
+      return createCctpDepositAddress(params, demo);
+    case "funxyz":
+      return createFunxyzDepositAddress(sdk, params, demo);
+  }
+}
+__name(createDepositAddressForRoute, "createDepositAddressForRoute");
+
+export { createDepositAddressForRoute, depositThroughRoute };

package/dist/helper/lighter/ethereum/usdc.helper.js

@@ -1,6 +1,14 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-const LIGHTER_CCTP_USDC_ADDRESSES = {
+const LIGHTER_NATIVE_USDC_ADDRESSES = {
+  // Ethereum
+  1: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  // OP Mainnet
+  10: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+  // Polygon PoS
+  137: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+  // Monad
+  143: "0x754704Bc059F8C67012fEd69BC8A327a5aafb603",
   // Arbitrum One
   42161: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
   // Base
@@ -8,9 +16,11 @@ const LIGHTER_CCTP_USDC_ADDRESSES = {
   // Avalanche C-Chain
   43114: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
   // HyperEVM
-  999: "0xb88339CB7199b77E23DB6E890353E22632Ba630f"
+  999: "0xb88339CB7199b77E23DB6E890353E22632Ba630f",
+  // Ink
+  57073: "0x2D270e6886d130D724215A266106e6832161EAEd"
 };
-const LIGHTER_CCTP_USDC_DECIMALS = 6;
+const LIGHTER_USDC_DECIMALS = 6;
 const usdcAbi = [
   {
     inputs: [
@@ -56,10 +66,10 @@ const usdcAbi = [
     type: "function"
   }
 ];
-function getLighterCctpUsdcAddress(chainId) {
-  return LIGHTER_CCTP_USDC_ADDRESSES[chainId];
+function getLighterNativeUsdcAddress(chainId) {
+  return LIGHTER_NATIVE_USDC_ADDRESSES[chainId];
 }
-__name(getLighterCctpUsdcAddress, "getLighterCctpUsdcAddress");
+__name(getLighterNativeUsdcAddress, "getLighterNativeUsdcAddress");
 async function writeUsdcTransfer(walletClient, params) {
   return walletClient.writeContract({
     chain: walletClient.chain,
@@ -74,4 +84,4 @@ async function writeUsdcTransfer(walletClient, params) {
 }
 __name(writeUsdcTransfer, "writeUsdcTransfer");
 
-export { LIGHTER_CCTP_USDC_ADDRESSES, LIGHTER_CCTP_USDC_DECIMALS, getLighterCctpUsdcAddress, usdcAbi, writeUsdcTransfer };
+export { LIGHTER_NATIVE_USDC_ADDRESSES, LIGHTER_USDC_DECIMALS, getLighterNativeUsdcAddress, usdcAbi, writeUsdcTransfer };

package/dist/helper/lighter/ethereum-deposit.helper.js

@@ -0,0 +1,44 @@
+import { parseUnits, parseEther } from 'viem';
+import { resolveAssetDecimals } from './asset-decimals.helper';
+import { writeDeposit } from './ethereum';
+import { AssetId } from './types';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+async function depositViaEthereumGateway(params, demo) {
+  if (demo) {
+    throw new Error("Lighter demo deposits are unavailable because the testnet gateway is not verified");
+  }
+  const l1Decimals = await resolveAssetDecimals(params.assetId, "l1_decimals", params.l1Decimals, demo);
+  const amount = parseUnits(params.amount, l1Decimals);
+  const value = readNativeValue(params, amount);
+  const txHash = await writeDeposit(params.walletClient, {
+    to: params.to,
+    assetIndex: params.assetId,
+    routeType: params.routeType,
+    // Ethereum deposits use the L1 token precision, not Lighter's L2/base-amount precision.
+    amount,
+    value
+  });
+  return {
+    route: "ethereum",
+    txHash
+  };
+}
+__name(depositViaEthereumGateway, "depositViaEthereumGateway");
+function readNativeValue(params, amount) {
+  if (params.assetId === AssetId.ETH) {
+    const value = parseEther(params.nativeValue ?? params.amount);
+    if (value !== amount) {
+      throw new Error("Lighter native ETH deposit amount and msg.value must match");
+    }
+    return value;
+  }
+  if (params.nativeValue !== void 0 && parseEther(params.nativeValue) !== 0n) {
+    throw new Error("Lighter nativeValue is only valid for ETH deposits");
+  }
+  return void 0;
+}
+__name(readNativeValue, "readNativeValue");
+
+export { depositViaEthereumGateway };