@continuumdao/ctm-mpc-defi 0.2.1 → 0.2.2

package/dist/protocols/evm/sky/index.d.ts

@@ -211,7 +211,62 @@ declare function buildSkySusdsDepositFromUsdsBatch(args: {
     messageToSign: string;
 }>;
 
+/** Debt in USDS wei matching `wipeAll` rounding (`_divup(art * rate, RAY)`). */
+declare function skyUsdsDebtWeiFromUrnArt(art: bigint, rate: bigint): bigint;
+type SkyLockstakePositionRow = {
+    index: number;
+    urn: Address;
+    inkWei: bigint;
+    art: bigint;
+    debtUsdsWei: bigint;
+    farm: Address;
+    /** Human-readable SKY locked */
+    skyLocked: string;
+    /** Human-readable USDS debt */
+    debtUsds: string;
+    /**
+     * Remaining borrow headroom in USD for UI only: `(SKY locked × SKY/USD × SKY_LOCKSTAKE_UI_COLLATERAL_FACTOR) − debtUSD`.
+     * Does not reflect on-chain liquidation price, oracle lag, stability fees, or protocol collateralization rules.
+     */
+    borrowLimitUsdApprox: number | null;
+    /** SKY/USD used only for the approximation above (same source as the dialog, e.g. CoinGecko). */
+    skyPriceUsd: number | null;
+};
+declare function loadSkyLockstakePositions(args: {
+    rpcUrl: string;
+    owner: Address;
+    skyUsd: number | null;
+}): Promise<SkyLockstakePositionRow[]>;
+/** ERC-20 paid by `LockstakeEngine.getReward` for this urn’s farm (farm-dependent; read on-chain). */
+declare function readSkyLockstakeFarmRewardsToken(args: {
+    rpcUrl: string;
+    farm: Address;
+}): Promise<Address>;
+
+declare function readSusdsVaultShareBalanceWei(args: {
+    rpcUrl: string;
+    owner: Address;
+}): Promise<bigint>;
+declare function readSusdsVaultDecimals(args: {
+    rpcUrl: string;
+}): Promise<number>;
+/** Approximate USDS out for `sharesWei` at current vault exchange rate (same block rules as `redeem`). */
+declare function readSusdsPreviewRedeemAssetsWei(args: {
+    rpcUrl: string;
+    sharesWei: bigint;
+}): Promise<bigint>;
+declare function formatSusdsSharesHuman(sharesWei: bigint, decimals: number): string;
+
+/** CoinGecko simple token price for SKY on Ethereum (USD). */
+declare function fetchSkyUsdFromCoinGecko(): Promise<number | null>;
+
+/**
+ * Chains where Sky LockStake Engine multisign flows are implemented.
+ * Sky tokens exist on other networks; LockStake staking/borrow in this app tracks engine deployments only.
+ */
+declare function loadSkyLockstakeSupportedChainIds(): ReadonlySet<number>;
+
 declare const SKY_PROTOCOL_ID = "sky";
 declare const skyProtocolModule: ProtocolModule;
 
-export { SKY_ETHEREUM_MAINNET, SKY_ETHEREUM_MAINNET_CHAIN_ID, SKY_LOCKSTAKE_DEFAULT_FARM_MAINNET, SKY_LOCKSTAKE_DEFAULT_FARM_REF, SKY_LOCKSTAKE_ENGINE_MAINNET, SKY_LOCKSTAKE_MULTICALL_FALLBACK_GAS, SKY_LOCKSTAKE_UI_COLLATERAL_FACTOR, SKY_LS_SKY_ERC20_MAINNET, SKY_PROTOCOL_ID, SKY_TOKEN_DECIMALS, SUSDS_VAULT_ERC4626_MAINNET, type SkyMultisignBatchStep, type SkyMultisignChainDetailRow, USDS_DECIMALS, USDS_ETHEREUM_MAINNET, appendSerializedSkyBatch, buildSkyLockstakeCloseBatch, buildSkyLockstakeDrawBatch, buildSkyLockstakeGetRewardBatch, buildSkyLockstakeStakePositionBatch, buildSkyLockstakeWipeBatch, buildSkySusdsDepositFromUsdsBatch, buildSkySusdsRedeemToUsdsBatch, isSkyLockstakeIsolationEstimateGasFragileBatchStep, resolveSkyLockstakeBatchStepGasFromSignRequest, skyProtocolModule };
+export { SKY_ETHEREUM_MAINNET, SKY_ETHEREUM_MAINNET_CHAIN_ID, SKY_LOCKSTAKE_DEFAULT_FARM_MAINNET, SKY_LOCKSTAKE_DEFAULT_FARM_REF, SKY_LOCKSTAKE_ENGINE_MAINNET, SKY_LOCKSTAKE_MULTICALL_FALLBACK_GAS, SKY_LOCKSTAKE_UI_COLLATERAL_FACTOR, SKY_LS_SKY_ERC20_MAINNET, SKY_PROTOCOL_ID, SKY_TOKEN_DECIMALS, SUSDS_VAULT_ERC4626_MAINNET, type SkyLockstakePositionRow, type SkyMultisignBatchStep, type SkyMultisignChainDetailRow, USDS_DECIMALS, USDS_ETHEREUM_MAINNET, appendSerializedSkyBatch, buildSkyLockstakeCloseBatch, buildSkyLockstakeDrawBatch, buildSkyLockstakeGetRewardBatch, buildSkyLockstakeStakePositionBatch, buildSkyLockstakeWipeBatch, buildSkySusdsDepositFromUsdsBatch, buildSkySusdsRedeemToUsdsBatch, fetchSkyUsdFromCoinGecko, formatSusdsSharesHuman, isSkyLockstakeIsolationEstimateGasFragileBatchStep, loadSkyLockstakePositions, loadSkyLockstakeSupportedChainIds, readSkyLockstakeFarmRewardsToken, readSusdsPreviewRedeemAssetsWei, readSusdsVaultDecimals, readSusdsVaultShareBalanceWei, resolveSkyLockstakeBatchStepGasFromSignRequest, skyProtocolModule, skyUsdsDebtWeiFromUrnArt };

package/dist/protocols/evm/sky/index.js

@@ -1,4 +1,4 @@
-import { parseAbi, defineChain, createPublicClient, http, getAddress, parseUnits, encodeFunctionData, decodeFunctionData, parseGwei, serializeTransaction, keccak256 } from 'viem';
+import { parseAbi, defineChain, createPublicClient, http, getAddress, parseUnits, encodeFunctionData, decodeFunctionData, formatUnits, parseGwei, serializeTransaction, keccak256 } from 'viem';
 import { fetchChainFeeParams, gasLimitFromEstimateAndChainConfig, gweiToDecimalString, proposalTxParamsToFeeSnapshot, alignEip1559FeesWithLatestBase, getClientIdFromKeyGenResult } from '@continuumdao/continuum-node-sdk';
 
 // src/core/registry.ts
@@ -1205,6 +1205,214 @@ async function buildSkySusdsDepositFromUsdsBatch(args) {
     purposePrefix,
     keyGen: args.keyGen});
 }
+var RAY = 10n ** 27n;
+var engineAbi2 = parseAbi([
+  "function ownerUrnsCount(address usr) view returns (uint256)",
+  "function ownerUrns(address owner, uint256 index) view returns (address urn)",
+  "function urnFarms(address urn) view returns (address farm)",
+  "function ilk() view returns (bytes32)",
+  "function vat() view returns (address)"
+]);
+var vatAbi = parseAbi([
+  "function urns(bytes32 ilk, address urn) view returns (uint256 ink, uint256 art)",
+  "function ilks(bytes32 ilk) view returns (uint256 Art, uint256 rate, uint256 spot, uint256 line, uint256 dust)"
+]);
+function skyClient(rpcUrl) {
+  const rpc = rpcUrl.trim();
+  const ch = defineChain({
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+  return createPublicClient({ chain: ch, transport: http(rpc) });
+}
+function skyUsdsDebtWeiFromUrnArt(art, rate) {
+  if (art === 0n || rate === 0n) return 0n;
+  return (art * rate + RAY - 1n) / RAY;
+}
+async function loadSkyLockstakePositions(args) {
+  const client = skyClient(args.rpcUrl);
+  const engine = getAddress(SKY_LOCKSTAKE_ENGINE_MAINNET);
+  const ilk = await client.readContract({
+    address: engine,
+    abi: engineAbi2,
+    functionName: "ilk"
+  });
+  const vat = await client.readContract({
+    address: engine,
+    abi: engineAbi2,
+    functionName: "vat"
+  });
+  const count = await client.readContract({
+    address: engine,
+    abi: engineAbi2,
+    functionName: "ownerUrnsCount",
+    args: [args.owner]
+  });
+  const n = Number(count);
+  if (!Number.isFinite(n) || n <= 0) return [];
+  const ilkInfo = await client.readContract({
+    address: vat,
+    abi: vatAbi,
+    functionName: "ilks",
+    args: [ilk]
+  });
+  const rate = ilkInfo[1];
+  const rows = [];
+  for (let index = 0; index < n; index++) {
+    const urn = await client.readContract({
+      address: engine,
+      abi: engineAbi2,
+      functionName: "ownerUrns",
+      args: [args.owner, BigInt(index)]
+    });
+    if (!urn || urn === "0x0000000000000000000000000000000000000000") continue;
+    const u = await client.readContract({
+      address: vat,
+      abi: vatAbi,
+      functionName: "urns",
+      args: [ilk, urn]
+    });
+    const inkWei = u[0];
+    const art = u[1];
+    const debtUsdsWei = skyUsdsDebtWeiFromUrnArt(art, rate);
+    const farm = await client.readContract({
+      address: engine,
+      abi: engineAbi2,
+      functionName: "urnFarms",
+      args: [urn]
+    });
+    const skyHuman = Number(formatUnits(inkWei, SKY_TOKEN_DECIMALS));
+    const debtHuman = Number(formatUnits(debtUsdsWei, USDS_DECIMALS));
+    let borrowLimitUsdApprox = null;
+    if (args.skyUsd != null && Number.isFinite(args.skyUsd) && args.skyUsd > 0) {
+      const collateralUsd = skyHuman * args.skyUsd;
+      const maxDebtUsd = collateralUsd * SKY_LOCKSTAKE_UI_COLLATERAL_FACTOR;
+      borrowLimitUsdApprox = Math.max(0, maxDebtUsd - debtHuman);
+    }
+    rows.push({
+      index,
+      urn,
+      inkWei,
+      art,
+      debtUsdsWei,
+      farm,
+      skyLocked: formatUnits(inkWei, SKY_TOKEN_DECIMALS),
+      debtUsds: formatUnits(debtUsdsWei, USDS_DECIMALS),
+      borrowLimitUsdApprox,
+      skyPriceUsd: args.skyUsd
+    });
+  }
+  return rows;
+}
+var farmRewardsTokenAbi = parseAbi(["function rewardsToken() view returns (address)"]);
+async function readSkyLockstakeFarmRewardsToken(args) {
+  const client = skyClient(args.rpcUrl);
+  const farm = getAddress(args.farm);
+  const zero = "0x0000000000000000000000000000000000000000";
+  if (farm.toLowerCase() === zero.toLowerCase()) {
+    throw new Error("Farm address is zero.");
+  }
+  const tok = await client.readContract({
+    address: farm,
+    abi: farmRewardsTokenAbi,
+    functionName: "rewardsToken"
+  });
+  return getAddress(tok);
+}
+var vaultAbi = parseAbi([
+  "function balanceOf(address account) view returns (uint256)",
+  "function decimals() view returns (uint8)",
+  "function previewRedeem(uint256 shares) view returns (uint256 assets)"
+]);
+async function readSusdsVaultShareBalanceWei(args) {
+  const rpc = args.rpcUrl.trim();
+  const ch = defineChain({
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+  const client = createPublicClient({ chain: ch, transport: http(rpc) });
+  const vault = getAddress(SUSDS_VAULT_ERC4626_MAINNET);
+  return client.readContract({
+    address: vault,
+    abi: vaultAbi,
+    functionName: "balanceOf",
+    args: [args.owner]
+  });
+}
+async function readSusdsVaultDecimals(args) {
+  const rpc = args.rpcUrl.trim();
+  const ch = defineChain({
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+  const client = createPublicClient({ chain: ch, transport: http(rpc) });
+  const vault = getAddress(SUSDS_VAULT_ERC4626_MAINNET);
+  const d = await client.readContract({
+    address: vault,
+    abi: vaultAbi,
+    functionName: "decimals"
+  });
+  return Number(d);
+}
+async function readSusdsPreviewRedeemAssetsWei(args) {
+  if (args.sharesWei <= 0n) return 0n;
+  const rpc = args.rpcUrl.trim();
+  const ch = defineChain({
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+  const client = createPublicClient({ chain: ch, transport: http(rpc) });
+  const vault = getAddress(SUSDS_VAULT_ERC4626_MAINNET);
+  return client.readContract({
+    address: vault,
+    abi: vaultAbi,
+    functionName: "previewRedeem",
+    args: [args.sharesWei]
+  });
+}
+function formatSusdsSharesHuman(sharesWei, decimals) {
+  return formatUnits(sharesWei, decimals);
+}
+
+// src/core/defiProxy.ts
+var coingeckoProxyUrl;
+function getCoingeckoProxyUrl() {
+  return coingeckoProxyUrl;
+}
+
+// src/protocols/evm/sky/usdPrice.ts
+async function fetchSkyUsdFromCoinGecko() {
+  try {
+    const addr = getAddress(SKY_ETHEREUM_MAINNET).toLowerCase();
+    const url = "https://api.coingecko.com/api/v3/simple/token_price/ethereum?contract_addresses=" + encodeURIComponent(addr) + "&vs_currencies=usd";
+    const proxy = getCoingeckoProxyUrl();
+    const res = proxy ? await fetch(proxy, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ platform: "ethereum", contractAddress: addr })
+    }) : await fetch(url, { cache: "no-store" });
+    if (!res.ok) return null;
+    const raw = await res.json();
+    const row = raw[addr];
+    const n = row?.usd;
+    return typeof n === "number" && Number.isFinite(n) && n > 0 ? n : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/protocols/evm/sky/loadLockstakeSupportedChainIds.ts
+function loadSkyLockstakeSupportedChainIds() {
+  return /* @__PURE__ */ new Set([1]);
+}
 
 // src/protocols/evm/sky/index.ts
 var SKY_PROTOCOL_ID = "sky";
@@ -1229,6 +1437,6 @@ var skyProtocolModule = {
 };
 registerProtocolModule(skyProtocolModule);
 
-export { SKY_ETHEREUM_MAINNET, SKY_ETHEREUM_MAINNET_CHAIN_ID, SKY_LOCKSTAKE_DEFAULT_FARM_MAINNET, SKY_LOCKSTAKE_DEFAULT_FARM_REF, SKY_LOCKSTAKE_ENGINE_MAINNET, SKY_LOCKSTAKE_MULTICALL_FALLBACK_GAS, SKY_LOCKSTAKE_UI_COLLATERAL_FACTOR, SKY_LS_SKY_ERC20_MAINNET, SKY_PROTOCOL_ID, SKY_TOKEN_DECIMALS, SUSDS_VAULT_ERC4626_MAINNET, USDS_DECIMALS, USDS_ETHEREUM_MAINNET, appendSerializedSkyBatch, buildSkyLockstakeCloseBatch, buildSkyLockstakeDrawBatch, buildSkyLockstakeGetRewardBatch, buildSkyLockstakeStakePositionBatch, buildSkyLockstakeWipeBatch, buildSkySusdsDepositFromUsdsBatch, buildSkySusdsRedeemToUsdsBatch, isSkyLockstakeIsolationEstimateGasFragileBatchStep, resolveSkyLockstakeBatchStepGasFromSignRequest, skyProtocolModule };
+export { SKY_ETHEREUM_MAINNET, SKY_ETHEREUM_MAINNET_CHAIN_ID, SKY_LOCKSTAKE_DEFAULT_FARM_MAINNET, SKY_LOCKSTAKE_DEFAULT_FARM_REF, SKY_LOCKSTAKE_ENGINE_MAINNET, SKY_LOCKSTAKE_MULTICALL_FALLBACK_GAS, SKY_LOCKSTAKE_UI_COLLATERAL_FACTOR, SKY_LS_SKY_ERC20_MAINNET, SKY_PROTOCOL_ID, SKY_TOKEN_DECIMALS, SUSDS_VAULT_ERC4626_MAINNET, USDS_DECIMALS, USDS_ETHEREUM_MAINNET, appendSerializedSkyBatch, buildSkyLockstakeCloseBatch, buildSkyLockstakeDrawBatch, buildSkyLockstakeGetRewardBatch, buildSkyLockstakeStakePositionBatch, buildSkyLockstakeWipeBatch, buildSkySusdsDepositFromUsdsBatch, buildSkySusdsRedeemToUsdsBatch, fetchSkyUsdFromCoinGecko, formatSusdsSharesHuman, isSkyLockstakeIsolationEstimateGasFragileBatchStep, loadSkyLockstakePositions, loadSkyLockstakeSupportedChainIds, readSkyLockstakeFarmRewardsToken, readSusdsPreviewRedeemAssetsWei, readSusdsVaultDecimals, readSusdsVaultShareBalanceWei, resolveSkyLockstakeBatchStepGasFromSignRequest, skyProtocolModule, skyUsdsDebtWeiFromUrnArt };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map