feat(programs): implement placeholder PythLazerAdapter and update adapter factory

cctdaniel · cctdaniel · commit 322fdb438f0c · 2025-05-12T11:50:51.000+09:00
diff --git a/governance/xc_admin/packages/xc_admin_common/src/index.ts b/governance/xc_admin/packages/xc_admin_common/src/index.ts
@@ -19,3 +19,5 @@ export { default as lazerIdl } from "./multisig_transaction/idl/lazer.json";
 export * from "./programs/program_adapter";
 export * from "./programs/types";
 export * from "./programs/adapter_factory";
+export * from "./programs/core/core_adapter";
+export * from "./programs/lazer/lazer_adapter";
diff --git a/governance/xc_admin/packages/xc_admin_common/src/programs/adapter_factory.ts b/governance/xc_admin/packages/xc_admin_common/src/programs/adapter_factory.ts
@@ -1,6 +1,7 @@
 import { ProgramAdapter } from "./program_adapter";
 import { ProgramType } from "./types";
 import { PythCoreAdapter } from "./core/core_adapter";
+import { PythLazerAdapter } from "./lazer/lazer_adapter";
 
 /**
  * Factory function to get the appropriate program adapter based on program type.
@@ -14,8 +15,7 @@ export function getProgramAdapter(type: ProgramType): ProgramAdapter {
     case ProgramType.PYTH_CORE:
       return new PythCoreAdapter();
     case ProgramType.PYTH_LAZER:
-      // Will be implemented in a future commit
-      throw new Error("Pyth Lazer adapter not yet implemented");
+      return new PythLazerAdapter();
     default:
       const exhaustiveCheck: never = type;
       throw new Error(`Unknown program type: ${exhaustiveCheck}`);
diff --git a/governance/xc_admin/packages/xc_admin_common/src/programs/lazer/lazer_adapter.ts b/governance/xc_admin/packages/xc_admin_common/src/programs/lazer/lazer_adapter.ts
@@ -0,0 +1,115 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { PythCluster } from "@pythnetwork/client";
+import { ProgramAdapter } from "../program_adapter";
+import { ProgramType } from "../types";
+
+/**
+ * Adapter for the next-generation Pyth Lazer oracle program
+ */
+export class PythLazerAdapter implements ProgramAdapter {
+  readonly name = "Pyth Lazer";
+  readonly description = "Next-generation Pyth oracle program";
+  readonly type = ProgramType.PYTH_LAZER;
+
+  private readonly LAZER_PROGRAM_ID = new PublicKey(
+    "pytd2yyk641x7ak7mkaasSJVXh6YYZnC7wTmtgAyxPt",
+  );
+
+  /**
+   * Get the program address for the given cluster
+   *
+   * @param cluster The Pyth cluster to get the address for
+   * @returns The program address
+   */
+  getProgramAddress(cluster: PythCluster): PublicKey {
+    // Currently using the same mock address for all clusters
+    // Will be updated with actual addresses for each cluster when available
+    return this.LAZER_PROGRAM_ID;
+  }
+
+  /**
+   * Check if the Pyth Lazer program is available on the specified cluster
+   *
+   * @param cluster The Pyth cluster to check
+   * @returns True if the program is available on the cluster
+   */
+  isAvailableOnCluster(cluster: PythCluster): boolean {
+    return (
+      cluster === "pythnet" ||
+      cluster === "mainnet-beta" ||
+      cluster === "devnet" ||
+      cluster === "testnet"
+    );
+  }
+
+  /**
+   * Parse raw on-chain accounts into a configuration object
+   *
+   * @param accounts Array of account data from the blockchain
+   * @param cluster The Pyth cluster where the accounts were fetched from
+   * @returns Lazer-specific configuration object
+   */
+  getConfigFromRawAccounts(accounts: any[], cluster: PythCluster): any {
+    // Not implemented yet - minimal placeholder
+    return {
+      programType: this.type,
+      cluster,
+      feeds: [],
+    };
+  }
+
+  /**
+   * Format the configuration for downloading as a JSON file
+   *
+   * @param config The program's configuration object
+   * @returns Configuration formatted for download
+   */
+  getDownloadableConfig(config: any): any {
+    // For now, just return an empty config
+    return {};
+  }
+
+  /**
+   * Validate an uploaded configuration against the current configuration
+   *
+   * @param existingConfig Current configuration
+   * @param uploadedConfig Configuration from an uploaded file
+   * @param cluster The Pyth cluster the configuration is for
+   * @returns Object with validation result and optional error message
+   */
+  validateUploadedConfig(
+    existingConfig: any,
+    uploadedConfig: any,
+    cluster: PythCluster,
+  ): {
+    isValid: boolean;
+    error?: string;
+    changes?: any;
+  } {
+    // Not implemented yet - return error
+    return {
+      isValid: false,
+      error: "Uploading configuration for Pyth Lazer is not yet supported",
+    };
+  }
+
+  /**
+   * Generate the necessary instructions to apply configuration changes
+   *
+   * @param changes Configuration changes to apply
+   * @param cluster The Pyth cluster where the changes will be applied
+   * @param accounts Additional context needed for generating instructions
+   * @returns Promise resolving to an array of TransactionInstructions
+   */
+  async generateInstructions(
+    changes: any,
+    cluster: PythCluster,
+    accounts: {
+      fundingAccount: PublicKey;
+      [key: string]: any;
+    },
+  ): Promise<TransactionInstruction[]> {
+    // Not implemented yet - return empty array
+    return [];
+  }
+}
diff --git a/governance/xc_admin/packages/xc_admin_frontend/hooks/usePyth.ts b/governance/xc_admin/packages/xc_admin_frontend/hooks/usePyth.ts
@@ -1,55 +1,34 @@
 import {
   AccountType,
+  PythCluster,
   getPythProgramKeyForCluster,
   parseBaseData,
-  parseMappingData,
-  parsePermissionData,
-  parsePriceData,
-  parseProductData,
-  PermissionData,
-  Product,
 } from '@pythnetwork/client'
-import { Connection, PublicKey } from '@solana/web3.js'
-import assert from 'assert'
+import { Connection } from '@solana/web3.js'
 import { useContext, useEffect, useRef, useState } from 'react'
 import { ClusterContext } from '../contexts/ClusterContext'
 import { deriveWsUrl, pythClusterApiUrls } from '../utils/pythClusterApiUrl'
+import { getProgramAdapter, ProgramType } from '@pythnetwork/xc-admin-common'
+import {
+  RawConfig,
+  MappingRawConfig,
+  ProductRawConfig,
+  PriceRawConfig,
+} from '@pythnetwork/xc-admin-common/src/programs/core/core_adapter'
 
 interface PythHookData {
   isLoading: boolean
   rawConfig: RawConfig
   connection?: Connection
 }
 
-export type RawConfig = {
-  mappingAccounts: MappingRawConfig[]
-  permissionAccount?: PermissionData
-}
-export type MappingRawConfig = {
-  address: PublicKey
-  next: PublicKey | null
-  products: ProductRawConfig[]
-}
-export type ProductRawConfig = {
-  address: PublicKey
-  priceAccounts: PriceRawConfig[]
-  metadata: Product
-}
-export type PriceRawConfig = {
-  next: PublicKey | null
-  address: PublicKey
-  expo: number
-  minPub: number
-  maxLatency: number
-  publishers: PublicKey[]
-}
-
 export const usePyth = (): PythHookData => {
   const connectionRef = useRef<Connection | undefined>(undefined)
   const { cluster } = useContext(ClusterContext)
   const [isLoading, setIsLoading] = useState(true)
   const [rawConfig, setRawConfig] = useState<RawConfig>({ mappingAccounts: [] })
   const [urlsIndex, setUrlsIndex] = useState(0)
+  const pythAdapter = useRef(getProgramAdapter(ProgramType.PYTH_CORE))
 
   useEffect(() => {
     setIsLoading(true)
@@ -72,116 +51,30 @@ export const usePyth = (): PythHookData => {
       try {
         const allPythAccounts = [
           ...(await connection.getProgramAccounts(
-            getPythProgramKeyForCluster(cluster)
+            getPythProgramKeyForCluster(cluster as PythCluster)
           )),
         ]
         if (cancelled) return
-        const priceRawConfigs: { [key: string]: PriceRawConfig } = {}
-
-        /// First pass, price accounts
-        let i = 0
-        while (i < allPythAccounts.length) {
-          const base = parseBaseData(allPythAccounts[i].account.data)
-          switch (base?.type) {
-            case AccountType.Price:
-              const parsed = parsePriceData(allPythAccounts[i].account.data)
-              priceRawConfigs[allPythAccounts[i].pubkey.toBase58()] = {
-                next: parsed.nextPriceAccountKey,
-                address: allPythAccounts[i].pubkey,
-                publishers: parsed.priceComponents.map((x) => {
-                  return x.publisher!
-                }),
-                expo: parsed.exponent,
-                minPub: parsed.minPublishers,
-                maxLatency: parsed.maxLatency,
-              }
-              allPythAccounts[i] = allPythAccounts[allPythAccounts.length - 1]
-              allPythAccounts.pop()
-              break
-            default:
-              i += 1
-          }
-        }
 
-        if (cancelled) return
-        /// Second pass, product accounts
-        i = 0
-        const productRawConfigs: { [key: string]: ProductRawConfig } = {}
-        while (i < allPythAccounts.length) {
-          const base = parseBaseData(allPythAccounts[i].account.data)
-          switch (base?.type) {
-            case AccountType.Product:
-              const parsed = parseProductData(allPythAccounts[i].account.data)
-              if (parsed.priceAccountKey) {
-                let priceAccountKey: string | undefined =
-                  parsed.priceAccountKey.toBase58()
-                const priceAccounts = []
-                while (priceAccountKey) {
-                  const toAdd: PriceRawConfig = priceRawConfigs[priceAccountKey]
-                  priceAccounts.push(toAdd)
-                  delete priceRawConfigs[priceAccountKey]
-                  priceAccountKey = toAdd.next
-                    ? toAdd.next.toBase58()
-                    : undefined
-                }
-                productRawConfigs[allPythAccounts[i].pubkey.toBase58()] = {
-                  priceAccounts,
-                  metadata: parsed.product,
-                  address: allPythAccounts[i].pubkey,
-                }
-              }
-              allPythAccounts[i] = allPythAccounts[allPythAccounts.length - 1]
-              allPythAccounts.pop()
-              break
-            default:
-              i += 1
-          }
-        }
+        // Use the adapter to parse the accounts
+        const parsedConfig = pythAdapter.current.getConfigFromRawAccounts(
+          allPythAccounts,
+          cluster as PythCluster
+        )
 
-        const rawConfig: RawConfig = { mappingAccounts: [] }
-        if (cancelled) return
-        /// Third pass, mapping accounts
-        i = 0
-        while (i < allPythAccounts.length) {
-          const base = parseBaseData(allPythAccounts[i].account.data)
-          switch (base?.type) {
-            case AccountType.Mapping:
-              const parsed = parseMappingData(allPythAccounts[i].account.data)
-              rawConfig.mappingAccounts.push({
-                next: parsed.nextMappingAccount,
-                address: allPythAccounts[i].pubkey,
-                products: parsed.productAccountKeys
-                  .filter((key) => productRawConfigs[key.toBase58()])
-                  .map((key) => {
-                    const toAdd = productRawConfigs[key.toBase58()]
-                    delete productRawConfigs[key.toBase58()]
-                    return toAdd
-                  }),
-              })
-              allPythAccounts[i] = allPythAccounts[allPythAccounts.length - 1]
-              allPythAccounts.pop()
-              break
-            case AccountType.Permission:
-              rawConfig.permissionAccount = parsePermissionData(
-                allPythAccounts[i].account.data
-              )
-              allPythAccounts[i] = allPythAccounts[allPythAccounts.length - 1]
-              allPythAccounts.pop()
-              break
-            default:
-              i += 1
-          }
-        }
+        // Verify all accounts were processed
+        const remainingAccounts = allPythAccounts.filter((account) => {
+          const base = parseBaseData(account.account.data)
+          return base && base.type !== AccountType.Test
+        })
 
-        assert(
-          allPythAccounts.every(
-            (x) =>
-              !parseBaseData(x.account.data) ||
-              parseBaseData(x.account.data)?.type == AccountType.Test
+        if (remainingAccounts.length > 0) {
+          console.warn(
+            `${remainingAccounts.length} accounts were not processed`
           )
-        )
+        }
 
-        setRawConfig(rawConfig)
+        setRawConfig(parsedConfig)
         setIsLoading(false)
       } catch (e) {
         if (cancelled) return
@@ -205,3 +98,6 @@ export const usePyth = (): PythHookData => {
     rawConfig,
   }
 }
+
+// Re-export the types for compatibility
+export type { RawConfig, MappingRawConfig, ProductRawConfig, PriceRawConfig }
