Fix/implement contract upgrade service methods

frontend/src/services/ContractUpgradeService.ts

@@ -1,5 +1,13 @@
 import { openContractCall } from '@stacks/connect';
-import { uintCV, principalCV, bufferCV, stringUtf8CV, PostConditionMode } from '@stacks/transactions';
+import {
+  uintCV,
+  principalCV,
+  bufferCV,
+  stringUtf8CV,
+  PostConditionMode,
+  callReadOnlyFunction,
+  cvToValue,
+} from '@stacks/transactions';
 
 export interface UpgradeProposal {
   newImplementation: string;
@@ -18,9 +26,11 @@ export interface UpgradeHistory {
 
 export class ContractUpgradeService {
   private proxyContract: { address: string; name: string };
+  private network: any;
 
-  constructor(proxyContract: { address: string; name: string }) {
+  constructor(proxyContract: { address: string; name: string }, network?: any) {
     this.proxyContract = proxyContract;
+    this.network = network;
   }
 
   async proposeUpgrade(newImplementation: string, userAddress: string): Promise<void> {
@@ -88,18 +98,268 @@ export class ContractUpgradeService {
   }
 
   async getImplementation(): Promise<string | null> {
-    return null;
+    try {
+      const contractAddress = this.extractAddress(this.proxyContract.address);
+      const response = await callReadOnlyFunction({
+        contractAddress,
+        contractName: this.proxyContract.name,
+        functionName: 'get-implementation',
+        functionArgs: [],
+        network: this.network,
+        senderAddress: contractAddress,
+      });
+
+      if (response.ok && response.value) {
+        const value = cvToValue(response.value);
+        return typeof value === 'string' ? value : null;
+      }
+      return null;
+    } catch (error) {
+      console.error('Failed to get implementation:', error);
+      return null;
+    }
+  }
+
+  private extractAddress(addressInput: string): string {
+    if (addressInput.includes('.')) {
+      return addressInput.split('.')[0];
+    }
+    return addressInput;
   }
 
   async getPendingUpgrade(): Promise<UpgradeProposal | null> {
-    return null;
+    try {
+      const contractAddress = this.extractAddress(this.proxyContract.address);
+      const response = await callReadOnlyFunction({
+        contractAddress,
+        contractName: this.proxyContract.name,
+        functionName: 'get-pending-implementation',
+        functionArgs: [],
+        network: this.network,
+        senderAddress: contractAddress,
+      });
+
+      if (response.ok && response.value) {
+        const result = cvToValue(response.value);
+        if (result && typeof result === 'object') {
+          return {
+            newImplementation: result as string,
+            proposedAt: 0,
+            proposedBy: '',
+            timelockExpires: 0,
+          };
+        }
+        if (result === null) {
+          return null;
+        }
+      }
+      return null;
+    } catch (error) {
+      console.error('Failed to get pending upgrade:', error);
+      return null;
+    }
   }
 
   async getUpgradeHistory(upgradeId: number): Promise<UpgradeHistory | null> {
-    return null;
+    try {
+      const contractAddress = this.extractAddress(this.proxyContract.address);
+      const response = await callReadOnlyFunction({
+        contractAddress,
+        contractName: this.proxyContract.name,
+        functionName: 'get-upgrade-history',
+        functionArgs: [uintCV(upgradeId)],
+        network: this.network,
+        senderAddress: contractAddress,
+      });
+
+      if (response.ok && response.value) {
+        const result = cvToValue(response.value);
+        if (result && typeof result === 'object') {
+          const history = result as any;
+          return {
+            upgradeId,
+            fromImplementation: history['from-implementation'] || '',
+            toImplementation: history['to-implementation'] || '',
+            upgradedAt: history['upgraded-at'] || 0,
+            upgradedBy: history['upgraded-by'] || '',
+          };
+        }
+      }
+      return null;
+    } catch (error) {
+      console.error(`Failed to get upgrade history ${upgradeId}:`, error);
+      return null;
+    }
   }
 
   async getUpgradeCount(): Promise<number> {
-    return 0;
+    try {
+      const contractAddress = this.extractAddress(this.proxyContract.address);
+      const response = await callReadOnlyFunction({
+        contractAddress,
+        contractName: this.proxyContract.name,
+        functionName: 'get-upgrade-count',
+        functionArgs: [],
+        network: this.network,
+        senderAddress: contractAddress,
+      });
+
+      if (response.ok && typeof response.value === 'object') {
+        const value = cvToValue(response.value);
+        return typeof value === 'number' ? value : 0;
+      }
+      return 0;
+    } catch (error) {
+      console.error('Failed to get upgrade count:', error);
+      return 0;
+    }
+  }
+
+  async getUpgradeTimelock(): Promise<number | null> {
+    try {
+      const contractAddress = this.extractAddress(this.proxyContract.address);
+      const response = await callReadOnlyFunction({
+        contractAddress,
+        contractName: this.proxyContract.name,
+        functionName: 'get-upgrade-timelock',
+        functionArgs: [],
+        network: this.network,
+        senderAddress: contractAddress,
+      });
+
+      if (response.ok && typeof response.value === 'object') {
+        const value = cvToValue(response.value);
+        return typeof value === 'number' ? value : null;
+      }
+      return null;
+    } catch (error) {
+      console.error('Failed to get upgrade timelock:', error);
+      return null;
+    }
+  }
+
+  async getOwner(): Promise<string | null> {
+    try {
+      const contractAddress = this.extractAddress(this.proxyContract.address);
+      const response = await callReadOnlyFunction({
+        contractAddress,
+        contractName: this.proxyContract.name,
+        functionName: 'get-owner',
+        functionArgs: [],
+        network: this.network,
+        senderAddress: contractAddress,
+      });
+
+      if (response.ok && response.value) {
+        const value = cvToValue(response.value);
+        return typeof value === 'string' ? value : null;
+      }
+      return null;
+    } catch (error) {
+      console.error('Failed to get owner:', error);
+      return null;
+    }
+  }
+
+  async isUpgradePending(): Promise<boolean> {
+    const pending = await this.getPendingUpgrade();
+    return pending !== null;
+  }
+
+  async canExecuteUpgrade(): Promise<boolean> {
+    const pending = await this.getPendingUpgrade();
+    if (!pending) {
+      return false;
+    }
+
+    const timelock = await this.getUpgradeTimelock();
+    if (timelock === null) {
+      return false;
+    }
+
+    return true;
+  }
+
+  async getUpgradeHistoryBatch(startId: number, count: number): Promise<(UpgradeHistory | null)[]> {
+    const results: (UpgradeHistory | null)[] = [];
+    for (let i = startId; i < startId + count; i++) {
+      const history = await this.getUpgradeHistory(i);
+      results.push(history);
+    }
+    return results;
+  }
+
+  async validateImplementationAddress(address: string): Promise<boolean> {
+    if (!address || typeof address !== 'string') {
+      return false;
+    }
+
+    const principalRegex = /^(ST|SM)[A-Z0-9]+$/i;
+    return principalRegex.test(address);
+  }
+
+  async compareImplementations(): Promise<{
+    current: string | null;
+    pending: UpgradeProposal | null;
+    same: boolean;
+  }> {
+    const current = await this.getImplementation();
+    const pending = await this.getPendingUpgrade();
+
+    return {
+      current,
+      pending,
+      same: current === pending?.newImplementation,
+    };
+  }
+
+  async getUpgradeMetadata(): Promise<{
+    owner: string | null;
+    current: string | null;
+    pending: UpgradeProposal | null;
+    timelock: number | null;
+    count: number;
+  }> {
+    const [owner, current, pending, timelock, count] = await Promise.all([
+      this.getOwner(),
+      this.getImplementation(),
+      this.getPendingUpgrade(),
+      this.getUpgradeTimelock(),
+      this.getUpgradeCount(),
+    ]);
+
+    return {
+      owner,
+      current,
+      pending,
+      timelock,
+      count,
+    };
+  }
+
+  async isImplementationValid(address: string): Promise<boolean> {
+    const isValid = await this.validateImplementationAddress(address);
+    if (!isValid) {
+      return false;
+    }
+
+    const current = await this.getImplementation();
+    return address !== current;
+  }
+
+  async getLastUpgradeRecord(): Promise<UpgradeHistory | null> {
+    const count = await this.getUpgradeCount();
+    if (count === 0) {
+      return null;
+    }
+
+    return this.getUpgradeHistory(count - 1);
+  }
+
+  private extractAddress(addressInput: string): string {
+    if (addressInput.includes('.')) {
+      return addressInput.split('.')[0];
+    }
+    return addressInput;
   }
 }