@pear-protocol/exchanges-sdk 0.7.0 → 0.9.0

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

@@ -0,0 +1,257 @@
+import { isAddress } from 'viem';
+import { parseUsdcAmount } from '../subaccount.helper';
+import { assertOwnerWallet, readUsdcAmountSyntaxError, formatUsdcUnits, readDepositMinimumError, emitProgress, watchAccountRegistration, waitForDepositPoll, SETTLEMENT_WATCH_LIMIT_MS } from './deposit-settlement.helper';
+import { getLighterNativeUsdcAddress, writeUsdcTransfer } from './ethereum/usdc.helper';
+import { FUNXYZ_DEPOSIT_MINIMUMS_USD, FUNXYZ_EVM_CHAIN_NAMES, FUNXYZ_ETHEREUM_MAINNET_CHAIN_ID } from './types';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const FUNXYZ_COMPLETED_STATUS = "COMPLETED";
+const FUNXYZ_PRE_ACCOUNT_RECIPIENT = "l1";
+async function createFunxyzDepositAddress(sdk, params, demo) {
+  assertFunxyzEnvironment(demo);
+  if (!isAddress(params.ownerAddress)) {
+    throw new Error(`Invalid Lighter Fun.xyz owner address: ${params.ownerAddress}`);
+  }
+  const uda = await mintUda(sdk, params.ownerAddress, params.market, params.asset, params.accountIndex);
+  return {
+    route: "funxyz",
+    evmAddress: uda.evmAddress,
+    ...uda.raw.solanaAddr ? {
+      solanaAddress: uda.raw.solanaAddr
+    } : {},
+    ...uda.raw.tronAddr ? {
+      tronAddress: uda.raw.tronAddr
+    } : {},
+    ...uda.raw.btcAddrSegwit ? {
+      bitcoinSegwitAddress: uda.raw.btcAddrSegwit
+    } : {},
+    credits: uda.credits
+  };
+}
+__name(createFunxyzDepositAddress, "createFunxyzDepositAddress");
+async function depositUsdcViaFunxyz(sdk, params, demo) {
+  assertFunxyzEnvironment(demo);
+  assertOwnerWallet(params.ownerAddress, params.connectedAddress);
+  assertFunxyzChain(params.chainId);
+  const usdcAddress = getLighterNativeUsdcAddress(params.chainId);
+  if (!usdcAddress) {
+    throw new Error(`This SDK cannot submit a Fun.xyz transfer on chain ID ${params.chainId}: its native USDC contract is not verified. Use createDepositAddress and send the funds yourself.`);
+  }
+  const syntaxError = readUsdcAmountSyntaxError(params.amount);
+  if (syntaxError) {
+    throw new Error(syntaxError);
+  }
+  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.`);
+  }
+  const uda = await mintUda(sdk, params.ownerAddress, params.market, "USDC", params.accountIndex);
+  const minimumError = readDepositMinimumError(units, readFunxyzMinimumUsd(readFunxyzChainSource(params.chainId), uda.credits.account));
+  if (minimumError) {
+    throw new Error(minimumError);
+  }
+  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 knownTxHashes = await readKnownBridgeTxHashes(sdk, params, uda.credits);
+  const txHash = await writeUsdcTransfer(wallet, {
+    usdcAddress,
+    to: uda.evmAddress,
+    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 followFunxyzSettlement(sdk, params, uda.credits, {
+    depositAddress: uda.evmAddress,
+    txHash,
+    chainId: params.chainId,
+    units
+  }, knownTxHashes, demo);
+  return {
+    route: "funxyz",
+    txHash,
+    depositAddress: uda.evmAddress,
+    credits: uda.credits
+  };
+}
+__name(depositUsdcViaFunxyz, "depositUsdcViaFunxyz");
+function readFunxyzMinimumUsd(source, account) {
+  return FUNXYZ_DEPOSIT_MINIMUMS_USD[source][account];
+}
+__name(readFunxyzMinimumUsd, "readFunxyzMinimumUsd");
+function listFunxyzTransferableChains() {
+  return Object.entries(FUNXYZ_EVM_CHAIN_NAMES).map(([chainId, name]) => ({
+    chainId: Number(chainId),
+    name
+  })).filter((chain) => getLighterNativeUsdcAddress(chain.chainId) !== void 0);
+}
+__name(listFunxyzTransferableChains, "listFunxyzTransferableChains");
+function readFunxyzChainSource(chainId) {
+  return chainId === FUNXYZ_ETHEREUM_MAINNET_CHAIN_ID ? "ethereum-mainnet" : "evm";
+}
+__name(readFunxyzChainSource, "readFunxyzChainSource");
+async function mintUda(sdk, ownerAddress, market, asset, accountIndex) {
+  const { uda } = await sdk.core.misc.lighter.createUda({
+    walletAddress: ownerAddress,
+    market,
+    asset,
+    ...accountIndex === void 0 ? {} : {
+      accountIndex
+    }
+  });
+  if (uda.status === "blocked") {
+    throw new Error(`The Fun.xyz bridge has blocked ${ownerAddress}. Deposits from this wallet are not accepted.`);
+  }
+  const { depositAddr } = uda;
+  if (!isAddress(depositAddr)) {
+    throw new Error("The Fun.xyz bridge returned an invalid EVM deposit address.");
+  }
+  return {
+    evmAddress: depositAddr,
+    credits: readFunxyzCredit(uda.resolved, ownerAddress),
+    raw: uda
+  };
+}
+__name(mintUda, "mintUda");
+function readFunxyzCredit(resolved, ownerAddress) {
+  if (resolved.userId.toLowerCase() !== ownerAddress.toLowerCase()) {
+    throw new Error(`The Fun.xyz bridge answered for ${resolved.userId}, not ${ownerAddress}. Deposits from this wallet are not accepted.`);
+  }
+  if (/^\d+$/.test(resolved.recipientAddr)) {
+    const accountIndex = Number(resolved.recipientAddr);
+    if (!Number.isSafeInteger(accountIndex)) {
+      throw new Error(`The Fun.xyz bridge returned an unusable Lighter account index: ${resolved.recipientAddr}`);
+    }
+    return {
+      account: "existing",
+      accountIndex
+    };
+  }
+  const recipient = resolved.recipientAddr.toLowerCase();
+  if (recipient !== FUNXYZ_PRE_ACCOUNT_RECIPIENT && recipient !== ownerAddress.toLowerCase()) {
+    throw new Error(`The Fun.xyz bridge named an unreadable Lighter recipient: ${resolved.recipientAddr}. Expected an account index or "${FUNXYZ_PRE_ACCOUNT_RECIPIENT}".`);
+  }
+  return {
+    account: "new",
+    ownerAddress
+  };
+}
+__name(readFunxyzCredit, "readFunxyzCredit");
+function assertFunxyzChain(chainId) {
+  if (!(chainId in FUNXYZ_EVM_CHAIN_NAMES)) {
+    const supported = Object.entries(FUNXYZ_EVM_CHAIN_NAMES).map(([id, name]) => `${name} (${id})`).join(", ");
+    throw new Error(`Unsupported Lighter Fun.xyz chain ID: ${chainId}. Fun.xyz accepts ${supported}.`);
+  }
+}
+__name(assertFunxyzChain, "assertFunxyzChain");
+function assertFunxyzEnvironment(demo) {
+  if (demo) {
+    throw new Error("Lighter demo Fun.xyz deposits are unavailable because the bridge serves mainnet only");
+  }
+}
+__name(assertFunxyzEnvironment, "assertFunxyzEnvironment");
+async function followFunxyzSettlement(sdk, params, credits, transfer, knownTxHashes, demo) {
+  if (!params.settlement) {
+    emitProgress(params.onProgress, params.signal, {
+      state: "untracked",
+      txHash: transfer.txHash
+    });
+    return;
+  }
+  switch (credits.account) {
+    case "existing": {
+      const transaction = await watchFunxyzBridge(sdk, params, transfer, knownTxHashes);
+      if (!transaction) {
+        return;
+      }
+      emitProgress(params.onProgress, params.signal, {
+        state: "credited",
+        txHash: transfer.txHash,
+        credit: {
+          source: "funxyz-bridge",
+          transaction
+        }
+      });
+      return;
+    }
+    case "new": {
+      await watchAccountRegistration(params.ownerAddress, transfer.txHash, params.onProgress, params.signal, demo);
+      return;
+    }
+  }
+}
+__name(followFunxyzSettlement, "followFunxyzSettlement");
+async function readKnownBridgeTxHashes(sdk, params, credits) {
+  if (!params.settlement || credits.account !== "existing") {
+    return void 0;
+  }
+  try {
+    const result = await sdk.core.misc.lighter.listUdaDeposits(params.ownerAddress);
+    return new Set(result.transactions.map((transaction) => transaction.txHash.toLowerCase()));
+  } catch {
+    return void 0;
+  }
+}
+__name(readKnownBridgeTxHashes, "readKnownBridgeTxHashes");
+async function watchFunxyzBridge(sdk, params, transfer, knownTxHashes) {
+  const signal = params.signal;
+  const deadline = Date.now() + SETTLEMENT_WATCH_LIMIT_MS;
+  while (!signal?.aborted) {
+    await waitForDepositPoll(signal);
+    if (signal?.aborted) {
+      return void 0;
+    }
+    if (Date.now() >= deadline) {
+      emitProgress(params.onProgress, signal, {
+        state: "unsettled",
+        txHash: transfer.txHash
+      });
+      return void 0;
+    }
+    let transactions;
+    try {
+      const result = await sdk.core.misc.lighter.listUdaDeposits(params.ownerAddress);
+      transactions = result.transactions;
+    } catch {
+      continue;
+    }
+    const transaction = findFunxyzTransaction(transactions, transfer, knownTxHashes);
+    if (!transaction || transaction.status !== FUNXYZ_COMPLETED_STATUS) {
+      emitProgress(params.onProgress, signal, {
+        state: "bridging",
+        txHash: transfer.txHash
+      });
+      continue;
+    }
+    return transaction;
+  }
+  return void 0;
+}
+__name(watchFunxyzBridge, "watchFunxyzBridge");
+function findFunxyzTransaction(transactions, transfer, knownTxHashes) {
+  const byHash = transactions.find((candidate) => candidate.txHash.toLowerCase() === transfer.txHash.toLowerCase());
+  if (byHash) {
+    return byHash;
+  }
+  if (!knownTxHashes) {
+    return void 0;
+  }
+  const candidates = transactions.filter((candidate) => candidate.depositAddr.toLowerCase() === transfer.depositAddress.toLowerCase() && !knownTxHashes.has(candidate.txHash.toLowerCase()) && candidate.fromChainId === String(transfer.chainId) && candidate.fromAmountBaseUnit === String(transfer.units));
+  return candidates.length === 1 ? candidates[0] : void 0;
+}
+__name(findFunxyzTransaction, "findFunxyzTransaction");
+
+export { createFunxyzDepositAddress, depositUsdcViaFunxyz, listFunxyzTransferableChains, readFunxyzChainSource, readFunxyzMinimumUsd };

package/dist/helper/lighter/helper.js

@@ -1,10 +1,12 @@
-import { parseUnits, isAddress, parseEther } from 'viem';
-import { fetchApiKeys, fetchAccount, fetchAccountsByL1Address, fetchAssetDetails } from '../../client/lighter/rest';
+import { parseUnits, isAddress } from 'viem';
+import { fetchApiKeys, fetchAccount, fetchPublicAccount, fetchAccountsByL1Address } from '../../client/lighter/rest';
 import { parseUsdcAmount } from '../subaccount.helper';
-import { depositUsdcViaCctp, createExternalCctpDepositIntent, listCctpDepositNetworks } from './cctp-deposit.helper';
-import { writeWithdraw, writeDeposit } from './ethereum';
+import { resolveAssetDecimals } from './asset-decimals.helper';
+import { listCctpDepositNetworks } from './cctp-deposit.helper';
+import { createDepositAddressForRoute, depositThroughRoute } from './deposit.helper';
+import { writeWithdraw } from './ethereum';
 import { LIGHTER_ACCOUNT_NOT_REGISTERED_CODE, readOnboardingStatus } from './onboarding.helper';
-import { MIN_LIGHTER_FAST_WITHDRAW_USDC, AssetId } from './types';
+import { MIN_LIGHTER_FAST_WITHDRAW_USDC } from './types';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -43,9 +45,9 @@ function createLighterHelper(sdk, demo = false) {
         subAccountIndexes: accounts.filter((s) => s.account_type !== 0).map((s) => s.index)
       };
     },
-    async checkIntegratorApproval(accountIndex, integratorAccountIndex, requirements) {
+    async checkIntegratorApproval(accountIndex, integratorAccountIndex, requirements, authToken) {
       if (requirements) validateApprovalRequirements(requirements);
-      const data = await fetchAccount(accountIndex, demo);
+      const data = authToken ? await fetchAccount(accountIndex, authToken, demo) : await fetchPublicAccount(accountIndex, demo);
       const account = data.accounts[0];
       if (!account) return false;
       const minMakerFee = requirements?.minPerpsMakerFee ?? 0;
@@ -102,45 +104,41 @@ function createLighterHelper(sdk, demo = false) {
         txHash
       };
     },
-    /** Lists the source networks Lighter credits through an intent address right now. */
-    async listDepositNetworks() {
-      return listCctpDepositNetworks(demo);
-    },
-    /** Creates a CCTP intent address for USDC deposits from a currently supported chain. */
-    async createExternalCctpDepositIntent(params) {
-      return createExternalCctpDepositIntent(params, demo);
-    },
-    /** Runs the complete direct native-USDC deposit flow. */
-    async depositUsdcViaCctp(params) {
-      return depositUsdcViaCctp(sdk, params, demo);
-    },
-    async deposit(walletClient, params) {
+    /**
+    * Moves the account onto another Lighter tier.
+    *
+    * Lighter allows this once every 24 hours, and only while the account holds no open orders or
+    * positions. It refuses the change itself and says which rule stopped it, so that wording
+    * arrives as the thrown error rather than being guessed at here.
+    */
+    async changeAccountTier(params) {
       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);
-      let value;
-      if (params.assetId === AssetId.ETH) {
-        value = parseEther(params.nativeValue ?? params.amount);
-        if (value !== amount) {
-          throw new Error("Lighter native ETH deposit amount and msg.value must match");
-        }
-      } else if (params.nativeValue !== void 0 && parseEther(params.nativeValue) !== 0n) {
-        throw new Error("Lighter nativeValue is only valid for ETH deposits");
+        throw new Error("Lighter demo tier changes are unavailable because backend signing is mainnet-only");
       }
-      const txHash = await writeDeposit(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
+      const result = await sdk.core.misc.lighter.changeAccountTier({
+        accountIndex: params.accountIndex,
+        apiKeyIndex: params.apiKeyIndex,
+        apiPrivateKey: params.apiPrivateKey,
+        tier: params.tier
       });
       return {
-        txHash
+        tier: result.tier
       };
     },
+    /** Lists the source networks Lighter credits through a CCTP intent address right now. */
+    async listCctpDepositNetworks() {
+      return listCctpDepositNetworks(demo);
+    },
+    /** Runs the deposit route the caller selected, from validation through settlement. */
+    async deposit(params) {
+      const result = await depositThroughRoute(sdk, params, demo);
+      return result;
+    },
+    /** Hands out an address any wallet or exchange may fund, for the route the caller selected. */
+    async createDepositAddress(params) {
+      const result = await createDepositAddressForRoute(sdk, params, demo);
+      return result;
+    },
     /** Performs a wallet-authorized fast USDC withdrawal through Lighter's transfer pool. */
     async fastWithdraw(walletClient, params) {
       if (demo) {
@@ -196,21 +194,6 @@ function createLighterHelper(sdk, demo = false) {
   return helper;
 }
 __name(createLighterHelper, "createLighterHelper");
-function validateDecimals(decimals, source) {
-  if (!Number.isSafeInteger(decimals) || decimals < 0 || decimals > 255) {
-    throw new Error(`Invalid ${source} decimals: ${decimals}`);
-  }
-  return decimals;
-}
-__name(validateDecimals, "validateDecimals");
-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 validateApprovalRequirements(requirements) {
   for (const [name, value] of [
     [

package/dist/helper/lighter/index.js

@@ -1,3 +1,5 @@
-export { LIGHTER_CCTP_USDC_ADDRESSES, LIGHTER_CCTP_USDC_DECIMALS, getLighterCctpUsdcAddress, usdcAbi } from './ethereum/usdc.helper';
+export { retrieveLighterAuthToken } from './auth-token.helper';
+export { LIGHTER_NATIVE_USDC_ADDRESSES, LIGHTER_USDC_DECIMALS, getLighterNativeUsdcAddress, usdcAbi } from './ethereum/usdc.helper';
+export { listFunxyzTransferableChains, readFunxyzChainSource, readFunxyzMinimumUsd } from './funxyz-deposit.helper';
 export * from './helper';
 export * from './types';

package/dist/helper/lighter/types.js

@@ -37,5 +37,38 @@ function getAssetDecimals(assetId) {
   return decimals;
 }
 __name(getAssetDecimals, "getAssetDecimals");
+const FUNXYZ_EVM_CHAIN_NAMES = {
+  1: "Ethereum",
+  10: "Optimism",
+  137: "Polygon",
+  143: "Monad",
+  999: "HyperEVM",
+  8453: "Base",
+  42161: "Arbitrum One",
+  57073: "Ink"
+};
+const FUNXYZ_ETHEREUM_MAINNET_CHAIN_ID = 1;
+const FUNXYZ_DEPOSIT_MINIMUMS_USD = {
+  "ethereum-mainnet": {
+    new: "5",
+    existing: "5"
+  },
+  evm: {
+    new: "5",
+    existing: "3"
+  },
+  solana: {
+    new: "5",
+    existing: "3"
+  },
+  tron: {
+    new: "5",
+    existing: "5"
+  },
+  bitcoin: {
+    new: "10",
+    existing: "10"
+  }
+};
 
-export { ASSET_DECIMALS, AssetId, L2_ASSET_DECIMALS, MIN_LIGHTER_CCTP_DEPOSIT_USDC, MIN_LIGHTER_FAST_WITHDRAW_USDC, RouteType, getAssetDecimals };
+export { ASSET_DECIMALS, AssetId, FUNXYZ_DEPOSIT_MINIMUMS_USD, FUNXYZ_ETHEREUM_MAINNET_CHAIN_ID, FUNXYZ_EVM_CHAIN_NAMES, L2_ASSET_DECIMALS, MIN_LIGHTER_CCTP_DEPOSIT_USDC, MIN_LIGHTER_FAST_WITHDRAW_USDC, RouteType, getAssetDecimals };