Add ability to renew expired/expiring delegations/proxies (#968)

ChewingGlass · web-flow · commit c2a75d2ccdb5 · 2025-06-03T11:52:48.000-07:00
* Add ability to renew proxies and delegations

* WIP

* Done
diff --git a/packages/helium-admin-cli/src/get-staked-wallets.ts b/packages/helium-admin-cli/src/get-staked-wallets.ts
@@ -0,0 +1,92 @@
+import * as anchor from "@coral-xyz/anchor";
+import { init as initVsr } from "@helium/voter-stake-registry-sdk";
+import os from "os";
+import yargs from "yargs";
+import { Connection, PublicKey } from "@solana/web3.js";
+import fs from "fs";
+import { AccountLayout } from "@solana/spl-token";
+
+export async function run(args: any = process.argv) {
+  const yarg = yargs(args).options({
+    wallet: {
+      alias: "k",
+      describe: "Anchor wallet keypair",
+      default: `${os.homedir()}/.config/solana/id.json`,
+    },
+    url: {
+      alias: "u",
+      default: "http://127.0.0.1:8899",
+      describe: "The solana url",
+    },
+    output: {
+      alias: "o",
+      describe: "Output file path for staked wallets",
+      type: "string",
+      demandOption: true,
+    },
+  });
+  const argv = await yarg.argv;
+  process.env.ANCHOR_WALLET = argv.wallet;
+  process.env.ANCHOR_PROVIDER_URL = argv.url;
+  anchor.setProvider(anchor.AnchorProvider.local(argv.url));
+
+  const provider = anchor.getProvider() as anchor.AnchorProvider;
+  const connection = new Connection(argv.url);
+
+  console.log("Initializing VSR program...");
+  const vsrProgram = await initVsr(provider);
+
+  console.log("Fetching all positions...");
+  const positions = await vsrProgram.account.positionV0.all();
+  console.log(`Found ${positions.length} total positions`);
+
+  // Get unique mints from positions
+  const mints = [...new Set(positions.filter(p => p.account.lockup.kind.constant || p.account.lockup.endTs.gte(new anchor.BN(Date.now() / 1000))).map(p => p.account.mint.toString()))];
+  console.log(`Found ${mints.length} unique mints to process`);
+
+  // Get token accounts for each mint and extract owner addresses
+  const stakedWallets = new Set<string>();
+
+  const batchSize = 10;
+  // Process mints in batches of batchSize
+  for (let i = 0; i < mints.length; i += batchSize) {
+    const mintBatch = mints.slice(i, i + batchSize);
+    const tokenAccountsPromises = mintBatch.map(mint => 
+      connection.getTokenLargestAccounts(new PublicKey(mint))
+    );
+    
+    const tokenAccountsResults = await Promise.all(tokenAccountsPromises);
+    
+    // Collect all token account addresses
+    const tokenAccountAddresses: PublicKey[] = [];
+    tokenAccountsResults.forEach(result => {
+      result.value.forEach(account => {
+        tokenAccountAddresses.push(account.address);
+      });
+    });
+
+    // Fetch all token accounts in one batch
+    const tokenAccountsInfo = await connection.getMultipleAccountsInfo(tokenAccountAddresses);
+    
+    // Parse token accounts and extract owners
+    tokenAccountsInfo.forEach((accountInfo, index) => {
+      if (accountInfo) {
+        try {
+          const tokenAccount = AccountLayout.decode(accountInfo.data);
+          stakedWallets.add(tokenAccount.owner.toString());
+        } catch (e) {
+          console.error(`Failed to parse token account at index ${index}`);
+        }
+      }
+    });
+
+    console.log(`Processed ${i / batchSize} of ${mints.length / batchSize} batches`);
+  }
+
+  // Convert Set to Array and write to file
+  const stakedWalletsArray = Array.from(stakedWallets);
+  console.log(`\nWriting ${stakedWalletsArray.length} unique staked wallets to ${argv.output}`);
+  fs.writeFileSync(argv.output, JSON.stringify(stakedWalletsArray, null, 2));
+
+  console.log("Done!");
+}
diff --git a/packages/voter-stake-registry-hooks/src/contexts/heliumVsrContext.tsx b/packages/voter-stake-registry-hooks/src/contexts/heliumVsrContext.tsx
@@ -5,7 +5,7 @@ import {
   delegatedPositionKey,
 } from "@helium/helium-sub-daos-sdk";
 import { VoterStakeRegistry } from "@helium/idls/lib/types/voter_stake_registry";
-import { init as initNftProxy } from "@helium/nft-proxy-sdk";
+import { init as initNftProxy, proxyConfigKey } from "@helium/nft-proxy-sdk";
 import { truthy } from "@helium/spl-utils";
 import { VoteService, init } from "@helium/voter-stake-registry-sdk";
 import { Connection, PublicKey } from "@solana/web3.js";
@@ -18,6 +18,7 @@ import { useRegistrar } from "../hooks/useRegistrar";
 import { PositionWithMeta, ProxyAssignmentV0 } from "../sdk/types";
 import { calcPositionVotingPower } from "../utils/calcPositionVotingPower";
 import { useRegistrarForMint } from "../hooks/useRegistrarForMint";
+import { useProxyConfig } from "../hooks/useProxyConfig";
 
 type Registrar = IdlAccounts<VoterStakeRegistry>["registrar"];
 
@@ -138,6 +139,8 @@ export const HeliumVsrStateProvider: React.FC<{
   const { accounts: delegatedAccounts, loading: loadingDel } =
     useDelegatedPositions(delegatedPositionKeys);
 
+  const { info: proxyConfig } = useProxyConfig(registrar?.proxyConfig);
+
   const proxyAccountsByAsset = useMemo(() => {
     return proxyAccounts?.reduce((acc, prox) => {
       acc[prox.asset.toBase58()] = prox;
@@ -236,6 +239,23 @@ export const HeliumVsrStateProvider: React.FC<{
 
             votingPower = votingPower.add(posVotingPower);
 
+            const proxyExpiration = proxy?.expirationTs;
+            const delegationExpiration = delegatedAccounts?.[
+              idx
+            ]?.info?.expirationTs;
+            const isProxyExpired = proxyExpiration?.lt(new BN(now));
+            const isDelegationExpired = delegationExpiration?.lt(new BN(now));
+            const currentSeason = proxyConfig?.seasons
+              ?.reverse()
+              ?.find((season) => season.start.lte(new BN(now)));
+
+            const isProxyRenewable =
+              proxyExpiration && !isProxyExpired && currentSeason?.end.gt(proxyExpiration);
+            const isDelegationRenewable =
+              delegationExpiration &&
+              !isDelegationExpired &&
+              currentSeason?.end.gt(delegationExpiration);
+
             return {
               ...position.info,
               pubkey: position?.publicKey,
@@ -247,6 +267,10 @@ export const HeliumVsrStateProvider: React.FC<{
               votingMint: mintCfgs[position.info.votingMintConfigIdx],
               isProxiedToMe,
               proxy,
+              isProxyExpired,
+              isDelegationExpired,
+              isProxyRenewable,
+              isDelegationRenewable,
             } as PositionWithMeta;
           }
         })
diff --git a/packages/voter-stake-registry-hooks/src/hooks/useAssignProxies.ts b/packages/voter-stake-registry-hooks/src/hooks/useAssignProxies.ts
@@ -127,7 +127,9 @@ export const useAssignProxies = () => {
           const subInstructions: TransactionInstruction[] = [];
           if (
             proxyAssignment &&
-            !proxyAssignment.nextVoter?.equals(PublicKey.default)
+            !proxyAssignment.nextVoter?.equals(PublicKey.default) &&
+            // Only unassign if the proxy is actually changing
+            !proxyAssignment.nextVoter.equals(recipient)
           ) {
             const toUndelegate =
               await voteService.getProxyAssignmentsForPosition(
diff --git a/packages/voter-stake-registry-hooks/src/hooks/useDelegatePosition.ts b/packages/voter-stake-registry-hooks/src/hooks/useDelegatePosition.ts
@@ -3,6 +3,7 @@ import {
   PROGRAM_ID,
   delegatedPositionKey,
   init,
+  subDaoEpochInfoKey,
 } from "@helium/helium-sub-daos-sdk";
 import { HNT_MINT, sendInstructions } from "@helium/spl-utils";
 import { init as initHplCrons } from "@helium/hpl-crons-sdk";
@@ -26,6 +27,9 @@ import {
 import { useDelegatedPosition } from "./useDelegatedPosition";
 import { nextAvailableTaskIds, taskKey } from "@helium/tuktuk-sdk";
 import { PREPAID_TX_FEES, usePositionFees } from "./usePositionFees";
+import { useRegistrar } from "./useRegistrar";
+import { useProxyConfig } from "./useProxyConfig";
+import { BN } from "@coral-xyz/anchor";
 
 export const useDelegatePosition = ({
   automationEnabled = false,
@@ -48,6 +52,8 @@ export const useDelegatePosition = ({
     useDelegationClaimBot(delegationClaimBotK);
   const { info: delegatedPositionAcc } = useDelegatedPosition(delegatedPosKey);
   const { info: taskQueue } = useTaskQueue(TASK_QUEUE);
+  const { info: registrar } = useRegistrar(position.registrar);
+  const { info: proxyConfig } = useProxyConfig(registrar?.proxyConfig);
 
   const { rentFee, prepaidTxFees, insufficientBalance } = usePositionFees({
     automationEnabled,
@@ -106,6 +112,38 @@ export const useDelegatePosition = ({
                 })
                 .instruction()
             );
+          } else if (position.isDelegated && position.isDelegationRenewable) {
+            const delegatedPosKey = delegatedPositionKey(position.pubkey)[0];
+            const delegatedPosAcc =
+              await hsdProgram.account.delegatedPositionV0.fetch(delegatedPosKey);
+            const now = new BN(Date.now() / 1000);
+            const newExpirationTs = proxyConfig?.seasons.reverse().find(
+              (season) => now.gte(season.start)
+            )?.end;
+            if (!newExpirationTs) {
+              throw new Error("No new valid expiration ts found");
+            }
+            const oldExpirationTs = delegatedPosAcc.expirationTs;
+
+            const oldSubDaoEpochInfo = subDaoEpochInfoKey(
+              delegatedPosAcc.subDao,
+              oldExpirationTs
+            )[0];
+            const newSubDaoEpochInfo = subDaoEpochInfoKey(
+              delegatedPosAcc.subDao,
+              newExpirationTs
+            )[0];
+            instructions.push(
+              await hsdProgram.methods
+                .extendExpirationTsV0()
+                .accountsPartial({
+                  position: position.pubkey,
+                  subDao: delegatedPosAcc.subDao,
+                  oldClosingTimeSubDaoEpochInfo: oldSubDaoEpochInfo,
+                  closingTimeSubDaoEpochInfo: newSubDaoEpochInfo,
+                })
+                .instruction()
+            );
           }
         }
 
diff --git a/packages/voter-stake-registry-hooks/src/hooks/useProxyConfig.ts b/packages/voter-stake-registry-hooks/src/hooks/useProxyConfig.ts
@@ -0,0 +1,10 @@
+import { useAnchorAccount, useAnchorAccounts } from "@helium/helium-react-hooks";
+import { PublicKey } from "@solana/web3.js";
+import { NftProxy } from "@helium/modular-governance-idls/lib/types/nft_proxy"
+
+export const useProxyConfig = (proxyConfigKey: PublicKey | undefined) => {
+  return useAnchorAccount<NftProxy, "proxyConfigV0">(
+    proxyConfigKey,
+    "proxyConfigV0"
+  );
+};
diff --git a/packages/voter-stake-registry-hooks/src/sdk/types.ts b/packages/voter-stake-registry-hooks/src/sdk/types.ts
@@ -29,6 +29,12 @@ export interface PositionWithMeta extends Position {
   votingPower: BN
   votingMint: VotingMintConfig
   proxy: Proxy | null
+  isProxyExpired: boolean,
+  isDelegationExpired: boolean,
+  /// Whether the proxy is within the 30 day renewal period
+  isProxyRenewable: boolean,
+  /// Whether the delegation is within the 30 day renewal period
+  isDelegationRenewable: boolean,
 }
 export type LockupKind = IdlTypes<HeliumVoterStakeRegistry>['lockupKind']
 /* export type InitializePositionV0Args = IdlTypes<HeliumVoterStakeRegistry>['InitializePositionArgsV0']
