Merge pull request #105 from 0xwml/wml/tha-2813-ethena-debug-ech-xlpt-sats-adapter

[echelon-xlpt] add adapter

Author: FJ-Riveros

constants/echelon.py

@@ -1,7 +1,15 @@
 LENDING_CONTRACT_ADDRESS = "0xc6bc659f1649553c1a3fa05d9727433dc03843baac29473c817d06d39e7621ba"
 
+XLPT_ORACLE_CONTRACT_ADDRESS = "0xff9c14f0ab345b7804388d93401f5f0651f29dff7082bf386eea9b7a695c769e"
+
 SUSDE_MARKET_ADDRESS = "0x778362f04f7904ba0b76913ec7c0c5cc04e469b0b96929c6998b34910690a740"
 
 SUSDE_TOKEN_ADDRESS = "0xb30a694a344edee467d9f82330bbe7c3b89f440a1ecd2da1f3bca266560fce69"
 
-ETHENA_ADDRESS_API_URL = "https://app.echelon.market/api/ethena-addresses"
+SUSDE_USDC_XLPT_MARKET_ADDRESS = "0x09c22785c5247e8bc491b2c19f25bbc313c5cd683a23a736bb358195bfbe81f1"
+
+SUSDE_USDC_TOKEN_ADDRESS = "0x35c3e420fa4fd925628366f1977865d62432c8856a2db147a1cb13f7207f6a79"
+
+ETHENA_ADDRESS_API_URL = "https://app.echelon.market/api/ethena-addresses"
+
+ETHENA_SUSDE_USDC_XLPT_ADDRESS_API_URL = "https://app.echelon.market/api/ethena-xlpt-addresses"

constants/example_integrations.py

@@ -21,6 +21,8 @@
 
 ECHELON_SUSDE_COLLATERAL_START_BLOCK = 2379805052
 
+ECHELON_SUSDE_USDC_XLPT_COLLATERAL_START_BLOCK = 2626780000
+
 RATEX_EXAMPLE_USDE_START_BLOCK = 21202656
 
 FIVA_EXAMPLE_USDE_START_BLOCK = 22370179

constants/thala.py

@@ -4,6 +4,8 @@
 
 ETHENA_ADDRESS_API_URL="https://app.thala.fi/api/ethena-addresses"
 
+ETHENA_XLPT_ADDRESS_API_URL="https://app.thala.fi/api/ethena-xlpt-addresses"
+
 THALA_FARMING_V1_ADDRESS = "0x6b3720cd988adeaf721ed9d4730da4324d52364871a68eac62b46d21e4d2fa99"
 
 THALASWAP_V2_ADDRESS = "0x7730cd28ee1cdc9e999336cbc430f99e7c44397c0aa77516f6f23a78559bb5"

integrations/echelon_xlpt_integration.py

@@ -0,0 +1,139 @@
+import logging
+import subprocess
+import json
+import requests
+
+from typing import Dict, List, Set
+from dotenv import load_dotenv
+from constants.summary_columns import SummaryColumn
+from constants.example_integrations import (
+    ECHELON_SUSDE_USDC_XLPT_COLLATERAL_START_BLOCK
+)
+from constants.echelon import LENDING_CONTRACT_ADDRESS, XLPT_ORACLE_CONTRACT_ADDRESS, SUSDE_USDC_XLPT_MARKET_ADDRESS, SUSDE_USDC_TOKEN_ADDRESS, ETHENA_SUSDE_USDC_XLPT_ADDRESS_API_URL
+from constants.chains import Chain
+from integrations.integration_ids import IntegrationID as IntID
+from integrations.l2_delegation_integration import L2DelegationIntegration
+
+load_dotenv()
+
+class EchelonAptosIntegration(L2DelegationIntegration):
+    def __init__(
+        self,
+        integration_id: IntID,
+        start_block: int,
+        token_address: str,
+        market_address: str,
+        decimals: int,
+        chain: Chain = Chain.APTOS,
+        reward_multiplier: int = 1,
+    ):
+        super().__init__(
+            integration_id=integration_id,
+            start_block=start_block,
+            chain=chain,
+            summary_cols=[SummaryColumn.ECHELON_SHARDS],
+            reward_multiplier=reward_multiplier,
+        )
+        self.token_address = token_address
+        self.market_address = market_address
+        self.decimals = str(decimals)
+        self.echelon_ts_location = "ts/echelon_xlpt_balances.ts"
+
+    def get_l2_block_balances(
+        self, cached_data: Dict[int, Dict[str, float]], blocks: List[int]
+    ) -> Dict[int, Dict[str, float]]:
+        logging.info("Getting block data for Echelon sUSDe/USDC xLPT Collateral...")
+        # Ensure blocks are sorted smallest to largest
+        block_data: Dict[int, Dict[str, float]] = {}
+        sorted_blocks = sorted(blocks)
+
+        # Populate block data from smallest to largest
+        for block in sorted_blocks:
+            user_addresses = self.get_participants(block)
+            result = self.get_participants_data(block, user_addresses[0:20])
+
+            # Store the balances and cache the exchange rate
+            block_data[block] = result
+
+        return block_data
+
+    def get_participants_data(self, block, user_addresses=[]):
+        print("Getting participants data for block", block)
+        try:
+            response = subprocess.run(
+                [
+                    "ts-node",
+                    self.echelon_ts_location,
+                    LENDING_CONTRACT_ADDRESS,
+                    self.market_address,
+                    str(self.decimals),
+                    str(block),
+                    json.dumps(user_addresses),
+                    XLPT_ORACLE_CONTRACT_ADDRESS,
+                    SUSDE_USDC_TOKEN_ADDRESS,
+                ],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            
+            # Debug output
+            print("TypeScript stdout:", response.stdout)
+            print("TypeScript stderr:", response.stderr)
+            
+            try:
+                result = json.loads(response.stdout)
+                return result  # Now returns dict with both balances and exchange rate
+            except json.JSONDecodeError as e:
+                print(f"JSON Decode Error: {e}")
+                print(f"Raw output: {response.stdout}")
+                raise
+                
+        except subprocess.CalledProcessError as e:
+            print(f"Process error: {e}")
+            print(f"stderr: {e.stderr}")
+            raise
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+            raise
+
+    def get_participants(self, block: int) -> List[str]:
+        try:
+            response = requests.get(
+                f"{ETHENA_SUSDE_USDC_XLPT_ADDRESS_API_URL}?block={block}",
+                timeout=10
+            )
+            response.raise_for_status()
+            
+            data = response.json()['data']
+            if not isinstance(data, list):
+                logging.warning(f"Unexpected response format from API: {data}")
+                return []
+                
+            return [addr for addr in data if isinstance(addr, str)]
+            
+        except requests.RequestException as e:
+            logging.error(f"Request failed for block {block}: {str(e)}")
+            return []
+        except Exception as e:
+            logging.error(f"Error processing participants for block {block}: {str(e)}")
+            return []
+
+if __name__ == "__main__":
+    example_integration = EchelonAptosIntegration(
+        integration_id=IntID.ECHELON_SUSDE_COLLATERAL,
+        start_block=ECHELON_SUSDE_USDC_XLPT_COLLATERAL_START_BLOCK,
+        market_address=SUSDE_USDC_XLPT_MARKET_ADDRESS,
+        token_address=SUSDE_USDC_TOKEN_ADDRESS,
+        decimals=8,
+        chain=Chain.APTOS,
+        reward_multiplier=5,
+    )
+
+    example_integration_output = example_integration.get_l2_block_balances(
+        cached_data={}, blocks=list(range(ECHELON_SUSDE_USDC_XLPT_COLLATERAL_START_BLOCK, ECHELON_SUSDE_USDC_XLPT_COLLATERAL_START_BLOCK + 40548182, 2000000))
+    )
+
+    print("=" * 120)
+    print("Run without cached data", example_integration_output)
+    print("=" * 120, "\n" * 5)

integrations/integration_ids.py

@@ -81,6 +81,12 @@ class IntegrationID(Enum):
         Token.SUSDE,
     )
 
+    ECHELON_SUSDE_USDC_XLPT_COLLATERAL = (
+        "echelon_susde_usdc_xlpt_collateral",
+        "Echelon sUSDe/USDC xLPT Collateral",
+        Token.SUSDE,
+    )
+
     # Stake DAO
     STAKEDAO_SUSDE_JULY_LPT = (
         "stakedao_susde_july_effective_lpt_held",

ts/echelon_xlpt_balances.ts

@@ -0,0 +1,89 @@
+import * as dotenv from "dotenv";
+import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+
+dotenv.config();
+
+const config = new AptosConfig({ network: Network.MAINNET });
+// Aptos is the main entrypoint for all functions
+const client = new Aptos(config);
+
+const args = process.argv.slice(2);
+const LENDING_CONTRACT_ADDRESS = args[0];
+const market_address = args[1];
+const decimals = Number(args[2]);
+const block = Number(args[3]);
+const user_addresses: string[] = JSON.parse(args[4]);
+const XLPT_ORACLE_ADDRESS = args[5];
+const SUSDE_USDC_TOKEN_ADDRESS = args[6];
+
+async function getStrategy() {
+  // iterate over all users and get their susde balance
+  const user_balances: Record<string, number> = {};
+  for (const address of user_addresses) {
+    const susde_usdc_xlpt_balance = await client.view({
+      payload: {
+        function: `${LENDING_CONTRACT_ADDRESS}::lending::account_coins`,
+        functionArguments: [address, market_address],
+      },
+      options: { ledgerVersion: block },
+    });
+
+    const susde_usdc_xlpt_price = await client.view({
+      payload: {
+        function: `${XLPT_ORACLE_ADDRESS}::oracle::get_price`,
+        functionArguments: [SUSDE_USDC_TOKEN_ADDRESS],
+      },
+      options: { ledgerVersion: block },
+    });
+
+    const susde_usdc_value = Number(susde_usdc_xlpt_balance) * fp64ToFloat(BigInt((susde_usdc_xlpt_price[0] as { v: string }).v));;
+
+    user_balances[address] = scaleDownByDecimals(
+      susde_usdc_value,
+      decimals
+    );
+  }
+
+  console.log(JSON.stringify(user_balances));
+}
+
+function scaleDownByDecimals(value: number, decimals: number) {
+  return value / 10 ** decimals;
+}
+
+const ZERO = BigInt(0);
+const ONE = BigInt(1);
+
+export const fp64ToFloat = (a: bigint): number => {
+  // avoid large number
+  let mask = BigInt("0xffffffff000000000000000000000000");
+  if ((a & mask) != ZERO) {
+    throw new Error("too large");
+  }
+
+  // integer part
+  mask = BigInt("0x10000000000000000");
+  let base = 1;
+  let result = 0;
+  for (let i = 0; i < 32; ++i) {
+    if ((a & mask) != ZERO) {
+      result += base;
+    }
+    base *= 2;
+    mask = mask << ONE;
+  }
+
+  // fractional part
+  mask = BigInt("0x8000000000000000");
+  base = 0.5;
+  for (let i = 0; i < 32; ++i) {
+    if ((a & mask) != ZERO) {
+      result += base;
+    }
+    base /= 2;
+    mask = mask >> ONE;
+  }
+  return result;
+};
+
+const strategy = getStrategy().catch(console.error);