@pear-protocol/exchanges-sdk 0.6.5 → 0.6.6

package/dist/helper/lighter/auth-token.helper.js

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ASSUMED_AUTH_TOKEN_TTL_SECONDS = 10 * 60;
+const AUTH_TOKEN_REFRESH_MARGIN_MS = 60 * 1e3;
+const cachedTokens = /* @__PURE__ */ new Map();
+async function retrieveLighterAuthToken(sdk, credentials, demo) {
+  const cacheKey = buildCacheKey(credentials, demo);
+  evictLapsedTokens();
+  const cached = cachedTokens.get(cacheKey);
+  if (cached && cached.apiPrivateKey === credentials.apiPrivateKey) {
+    return cached.token;
+  }
+  let entry;
+  const token = signAuthToken(sdk, credentials).catch((error) => {
+    if (cachedTokens.get(cacheKey) === entry) {
+      cachedTokens.delete(cacheKey);
+    }
+    throw error;
+  });
+  entry = {
+    token,
+    apiPrivateKey: credentials.apiPrivateKey,
+    expiresAt: Date.now() + ASSUMED_AUTH_TOKEN_TTL_SECONDS * 1e3 - AUTH_TOKEN_REFRESH_MARGIN_MS
+  };
+  cachedTokens.set(cacheKey, entry);
+  void token.then((signed) => alignExpiry(cacheKey, entry, signed)).catch(() => void 0);
+  return token;
+}
+__name(retrieveLighterAuthToken, "retrieveLighterAuthToken");
+function _resetLighterAuthTokens() {
+  cachedTokens.clear();
+}
+__name(_resetLighterAuthTokens, "_resetLighterAuthTokens");
+async function signAuthToken(sdk, credentials) {
+  const { token } = await sdk.core.misc.lighter.createAuthToken({
+    accountIndex: credentials.accountIndex,
+    apiKeyIndex: credentials.apiKeyIndex,
+    apiPrivateKey: credentials.apiPrivateKey
+  });
+  return token;
+}
+__name(signAuthToken, "signAuthToken");
+function alignExpiry(cacheKey, entry, token) {
+  if (cachedTokens.get(cacheKey) !== entry) {
+    return;
+  }
+  const deadlineSeconds = Number(token.split(":")[0]);
+  if (!Number.isSafeInteger(deadlineSeconds) || deadlineSeconds <= 0) {
+    return;
+  }
+  entry.expiresAt = Math.min(entry.expiresAt, deadlineSeconds * 1e3 - AUTH_TOKEN_REFRESH_MARGIN_MS);
+}
+__name(alignExpiry, "alignExpiry");
+function buildCacheKey(credentials, demo) {
+  return `${demo ? "demo" : "live"}:${credentials.accountIndex}:${credentials.apiKeyIndex}`;
+}
+__name(buildCacheKey, "buildCacheKey");
+function evictLapsedTokens() {
+  const now = Date.now();
+  for (const [cacheKey, cached] of cachedTokens) {
+    if (cached.expiresAt <= now) {
+      cachedTokens.delete(cacheKey);
+    }
+  }
+}
+__name(evictLapsedTokens, "evictLapsedTokens");
+
+export { _resetLighterAuthTokens, retrieveLighterAuthToken };

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

@@ -0,0 +1,297 @@
+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 { 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) {
+  await validateIntentRoute(params, demo);
+  const intentAddress = await createCctpDepositIntentAddress({
+    chainId: params.chainId,
+    fromAddress: params.ownerAddress,
+    amount: "0",
+    external: true
+  }, demo);
+  return {
+    intentAddress,
+    expiresAt: Date.now() + EXTERNAL_INTENT_LIFETIME_MS
+  };
+}
+__name(createExternalCctpDepositIntent, "createExternalCctpDepositIntent");
+async function depositUsdcViaCctp(sdk, params, demo) {
+  assertCctpEnvironment(demo);
+  assertOwnerWallet(params.ownerAddress, params.connectedAddress);
+  const usdcAddress = getLighterCctpUsdcAddress(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 units = parseUsdcAmount(params.amount);
+  const balance = await params.wallet.readUsdcBalance(params.chainId, params.ownerAddress);
+  if (units > balance) {
+    throw new Error(`Your wallet holds ${formatUsdcUnits(balance)} USDC.`);
+  }
+  await validateIntentRoute({
+    chainId: params.chainId,
+    ownerAddress: params.ownerAddress
+  }, demo);
+  const wallet = await params.wallet.retrieveWallet(params.chainId);
+  if (wallet.account.address.toLowerCase() !== params.ownerAddress.toLowerCase()) {
+    throw new Error(`Connect the Lighter owner wallet ${params.ownerAddress} and try again.`);
+  }
+  if (wallet.chain?.id !== params.chainId) {
+    throw new Error(`Switch the wallet to chain ${params.chainId} before depositing.`);
+  }
+  const intentAddress = await createCctpDepositIntentAddress({
+    chainId: params.chainId,
+    fromAddress: params.ownerAddress,
+    amount: units.toString(),
+    external: false
+  }, demo);
+  const txHash = await writeUsdcTransfer(wallet, {
+    usdcAddress,
+    to: intentAddress,
+    amount: BigInt(units)
+  });
+  emitProgress(params.onProgress, params.signal, {
+    state: "confirming",
+    txHash
+  });
+  await params.wallet.confirmTransaction(params.chainId, txHash);
+  emitProgress(params.onProgress, params.signal, {
+    state: "bridging",
+    txHash
+  });
+  await followDepositSettlement(params, txHash, sdk, demo);
+  return {
+    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)) {
+    throw new Error(`Invalid Lighter CCTP owner address: ${params.ownerAddress}`);
+  }
+  const networks = await fetchDepositNetworks(demo);
+  if (!networks.some((network) => network.chainId === params.chainId)) {
+    const supported = networks.map((network) => `${network.name} (${network.chainId})`).join(", ");
+    throw new Error(`Unsupported Lighter CCTP chain ID: ${params.chainId}. Lighter accepts ${supported}.`);
+  }
+}
+__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");
+  }
+}
+__name(assertCctpEnvironment, "assertCctpEnvironment");
+async function followDepositSettlement(params, txHash, sdk, demo) {
+  const settlement = params.settlement;
+  if (!settlement) {
+    emitProgress(params.onProgress, params.signal, {
+      state: "untracked",
+      txHash
+    });
+    return;
+  }
+  switch (settlement.follow) {
+    case "deposit-history": {
+      const watch = await resolveDepositWatch(params.ownerAddress, settlement, params.signal, demo);
+      if (!watch) {
+        emitProgress(params.onProgress, params.signal, {
+          state: "untracked",
+          txHash
+        });
+        return;
+      }
+      await watchCctpDeposit(params.ownerAddress, txHash, watch, params.onProgress, sdk, demo);
+      return;
+    }
+    case "account-registration": {
+      await watchAccountRegistration(params.ownerAddress, txHash, params.onProgress, params.signal, demo);
+      return;
+    }
+  }
+}
+__name(followDepositSettlement, "followDepositSettlement");
+async function resolveDepositWatch(ownerAddress, settlement, signal, demo) {
+  const data = await fetchAccountsByL1Address(ownerAddress, demo);
+  const main = data.sub_accounts?.find((account) => account.account_type === 0);
+  if (!main || main.index !== settlement.selectedAccountIndex) {
+    return void 0;
+  }
+  const credentials = await settlement.retrieveCredentials();
+  return {
+    accountIndex: main.index,
+    apiKeyIndex: credentials.apiKeyIndex,
+    apiPrivateKey: credentials.apiPrivateKey,
+    signal
+  };
+}
+__name(resolveDepositWatch, "resolveDepositWatch");
+async function watchCctpDeposit(ownerAddress, txHash, watch, onProgress, sdk, demo) {
+  while (!watch.signal?.aborted) {
+    await waitForDepositPoll(watch.signal);
+    if (watch.signal?.aborted) {
+      return;
+    }
+    let deposits;
+    try {
+      const authToken = await retrieveLighterAuthToken(sdk, watch, demo);
+      deposits = await fetchDepositHistory({
+        accountIndex: watch.accountIndex,
+        l1Address: ownerAddress,
+        authToken
+      }, demo);
+    } catch {
+      continue;
+    }
+    const deposit = deposits.find((candidate) => candidate.l1TxHash.toLowerCase() === txHash.toLowerCase());
+    if (!deposit) {
+      emitProgress(onProgress, watch.signal, {
+        state: "bridging",
+        txHash
+      });
+      continue;
+    }
+    switch (deposit.status) {
+      case "pending":
+        emitProgress(onProgress, watch.signal, {
+          state: "bridging",
+          txHash
+        });
+        break;
+      case "completed":
+        emitProgress(onProgress, watch.signal, {
+          state: "credited",
+          txHash,
+          deposit
+        });
+        return;
+      case "failed":
+        emitProgress(onProgress, watch.signal, {
+          state: "failed",
+          txHash,
+          deposit
+        });
+        return;
+      case "claimable":
+        emitProgress(onProgress, watch.signal, {
+          state: "action-required",
+          txHash,
+          deposit
+        });
+        return;
+    }
+  }
+}
+__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 };

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

@@ -2,9 +2,21 @@ const LIGHTER_GATEWAY_ADDRESS = "0x3B4D794a66304F130a4Db8F2551B0070dfCf5ca7";
 const lighterGatewayAbi = [
   {
     inputs: [
-      { internalType: "uint48", name: "_accountIndex", type: "uint48" },
-      { internalType: "uint8", name: "_apiKeyIndex", type: "uint8" },
-      { internalType: "bytes", name: "_pubKey", type: "bytes" }
+      {
+        internalType: "uint48",
+        name: "_accountIndex",
+        type: "uint48"
+      },
+      {
+        internalType: "uint8",
+        name: "_apiKeyIndex",
+        type: "uint8"
+      },
+      {
+        internalType: "bytes",
+        name: "_pubKey",
+        type: "bytes"
+      }
     ],
     name: "changePubKey",
     outputs: [],
@@ -13,10 +25,26 @@ const lighterGatewayAbi = [
   },
   {
     inputs: [
-      { internalType: "address", name: "_to", type: "address" },
-      { internalType: "uint16", name: "_assetIndex", type: "uint16" },
-      { internalType: "uint8", name: "_routeType", type: "uint8" },
-      { internalType: "uint256", name: "_amount", type: "uint256" }
+      {
+        internalType: "address",
+        name: "_to",
+        type: "address"
+      },
+      {
+        internalType: "uint16",
+        name: "_assetIndex",
+        type: "uint16"
+      },
+      {
+        internalType: "uint8",
+        name: "_routeType",
+        type: "uint8"
+      },
+      {
+        internalType: "uint256",
+        name: "_amount",
+        type: "uint256"
+      }
     ],
     name: "deposit",
     outputs: [],
@@ -25,10 +53,26 @@ const lighterGatewayAbi = [
   },
   {
     inputs: [
-      { internalType: "uint48", name: "_accountIndex", type: "uint48" },
-      { internalType: "uint16", name: "_assetIndex", type: "uint16" },
-      { internalType: "uint8", name: "_routeType", type: "uint8" },
-      { internalType: "uint64", name: "_baseAmount", type: "uint64" }
+      {
+        internalType: "uint48",
+        name: "_accountIndex",
+        type: "uint48"
+      },
+      {
+        internalType: "uint16",
+        name: "_assetIndex",
+        type: "uint16"
+      },
+      {
+        internalType: "uint8",
+        name: "_routeType",
+        type: "uint8"
+      },
+      {
+        internalType: "uint64",
+        name: "_baseAmount",
+        type: "uint64"
+      }
     ],
     name: "withdraw",
     outputs: [],

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

@@ -1,6 +1,8 @@
 import { mainnet } from 'viem/chains';
 import { lighterGatewayAbi, LIGHTER_GATEWAY_ADDRESS } from './abi';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 const chain = mainnet;
 async function writeChangePubKey(walletClient, params) {
   return walletClient.writeContract({
@@ -8,27 +10,44 @@ async function writeChangePubKey(walletClient, params) {
     address: LIGHTER_GATEWAY_ADDRESS,
     abi: lighterGatewayAbi,
     functionName: "changePubKey",
-    args: [params.accountIndex, params.apiKeyIndex, params.pubKey]
+    args: [
+      params.accountIndex,
+      params.apiKeyIndex,
+      params.pubKey
+    ]
   });
 }
+__name(writeChangePubKey, "writeChangePubKey");
 async function writeDeposit(walletClient, params) {
   return walletClient.writeContract({
     chain,
     address: LIGHTER_GATEWAY_ADDRESS,
     abi: lighterGatewayAbi,
     functionName: "deposit",
-    args: [params.to, params.assetIndex, params.routeType, params.amount],
+    args: [
+      params.to,
+      params.assetIndex,
+      params.routeType,
+      params.amount
+    ],
     value: params.value ?? 0n
   });
 }
+__name(writeDeposit, "writeDeposit");
 async function writeWithdraw(walletClient, params) {
   return walletClient.writeContract({
     chain,
     address: LIGHTER_GATEWAY_ADDRESS,
     abi: lighterGatewayAbi,
     functionName: "withdraw",
-    args: [params.accountIndex, params.assetIndex, params.routeType, params.baseAmount]
+    args: [
+      params.accountIndex,
+      params.assetIndex,
+      params.routeType,
+      params.baseAmount
+    ]
   });
 }
+__name(writeWithdraw, "writeWithdraw");
 
 export { writeChangePubKey, writeDeposit, writeWithdraw };

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

@@ -0,0 +1,77 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const LIGHTER_CCTP_USDC_ADDRESSES = {
+  // Arbitrum One
+  42161: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  // Base
+  8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  // Avalanche C-Chain
+  43114: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+  // HyperEVM
+  999: "0xb88339CB7199b77E23DB6E890353E22632Ba630f"
+};
+const LIGHTER_CCTP_USDC_DECIMALS = 6;
+const usdcAbi = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      }
+    ],
+    name: "transfer",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "account",
+        type: "address"
+      }
+    ],
+    name: "balanceOf",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+function getLighterCctpUsdcAddress(chainId) {
+  return LIGHTER_CCTP_USDC_ADDRESSES[chainId];
+}
+__name(getLighterCctpUsdcAddress, "getLighterCctpUsdcAddress");
+async function writeUsdcTransfer(walletClient, params) {
+  return walletClient.writeContract({
+    chain: walletClient.chain,
+    address: params.usdcAddress,
+    abi: usdcAbi,
+    functionName: "transfer",
+    args: [
+      params.to,
+      params.amount
+    ]
+  });
+}
+__name(writeUsdcTransfer, "writeUsdcTransfer");
+
+export { LIGHTER_CCTP_USDC_ADDRESSES, LIGHTER_CCTP_USDC_DECIMALS, getLighterCctpUsdcAddress, usdcAbi, writeUsdcTransfer };