Merge remote-tracking branch 'origin/master' into develop

packages/helium-admin-cli/proxy-seasons.json

@@ -1,5 +1,4 @@
 [
-  { "start": "2023-07-01T00:00:00Z", "end": "2024-08-01T00:00:00Z" },
   { "start": "2024-07-01T00:00:00Z", "end": "2025-08-01T00:00:00Z" },
   { "start": "2025-07-01T00:00:00Z", "end": "2026-08-01T00:00:00Z" },
   { "start": "2026-07-01T00:00:00Z", "end": "2027-08-01T00:00:00Z" },

packages/helium-admin-cli/src/fix-claimed-epochs.ts

@@ -0,0 +1,67 @@
+import * as anchor from "@coral-xyz/anchor";
+import {
+  lazyDistributorKey
+} from "@helium/lazy-distributor-sdk";
+import { init as initHsd } from "@helium/helium-sub-daos-sdk";
+import { organizationKey } from "@helium/organization-sdk";
+import { oracleSignerKey } from "@helium/rewards-oracle-sdk";
+import {
+  batchParallelInstructionsWithPriorityFee
+} from "@helium/spl-utils";
+import { getAssociatedTokenAddressSync } from "@solana/spl-token";
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import Squads from "@sqds/sdk";
+import fs from "fs";
+import os from "os";
+import yargs from "yargs/yargs";
+import {
+  loadKeypair,
+  parseEmissionsSchedule,
+  sendInstructionsOrSquads,
+} from "./utils";
+
+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",
+    },
+    delegatedPositions: {
+      type: "string",
+      describe: "Path to the delegated positions file",
+      default: __dirname + "/delegatedPositions.txt",
+    },
+  });
+  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 wallet = new anchor.Wallet(loadKeypair(argv.wallet));
+  const hsdProgram = await initHsd(provider);
+
+  const delegatedPositions = fs.readFileSync(argv.delegatedPositions, "utf-8")
+    .split("\n")
+    .filter(line => line.trim() !== ""); // Remove empty lines
+
+  const instructions: TransactionInstruction[] = [];
+  for (const delegatedPosition of delegatedPositions) {
+    console.log(delegatedPosition, new PublicKey(delegatedPosition).toBase58());
+    instructions.push(
+      await hsdProgram.methods
+        .tempFixClaimedEpoch()
+        .accounts({
+          authority: wallet.publicKey,
+          delegatedPosition: new PublicKey(delegatedPosition),
+        })
+        .instruction()
+    );
+  }
+  await batchParallelInstructionsWithPriorityFee(provider, instructions, {maxSignatureBatch: 100});
+}

packages/helium-admin-cli/src/update-proxy-config.ts

@@ -0,0 +1,100 @@
+import * as anchor from "@coral-xyz/anchor";
+import {
+  init as initProxy,
+  proxyConfigKey,
+} from "@helium/nft-proxy-sdk";
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import Squads from "@sqds/sdk";
+import fs from "fs";
+import os from "os";
+import yargs from "yargs/yargs";
+import {
+  loadKeypair,
+  sendInstructionsOrSquads
+} from "./utils";
+
+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",
+    },
+    name: {
+      required: true,
+      type: "string",
+      describe: "Name of the proxy config to be updated",
+    },
+    maxProxyTime: {
+      required: false,
+      describe: "New max proxy time",
+      type: "string",
+      default: null,
+    },
+    proxySeasonsFile: {
+      type: "string",
+      default: `${__dirname}/../../proxy-seasons.json`,
+    },
+    executeTransaction: {
+      type: "boolean",
+    },
+    multisig: {
+      type: "string",
+      describe:
+        "Address of the squads multisig to be authority. If not provided, your wallet will be the authority",
+    },
+    authorityIndex: {
+      type: "number",
+      describe: "Authority index for squads. Defaults to 1",
+      default: 1,
+    },
+  });
+  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 wallet = new anchor.Wallet(loadKeypair(argv.wallet));
+  const proxySeasonsFile = fs.readFileSync(argv.proxySeasonsFile, "utf8");
+  const seasons = JSON.parse(proxySeasonsFile).map((s) => ({
+    start: new anchor.BN(Math.floor(Date.parse(s.start) / 1000)),
+    end: new anchor.BN(Math.floor(Date.parse(s.end) / 1000)),
+  }));
+
+  const program = await initProxy(provider);
+
+  const instructions: TransactionInstruction[] = [];
+  const proxyConfig = proxyConfigKey(argv.name)[0];
+  const proxyConfigAcc = await program.account.proxyConfigV0.fetch(proxyConfig);
+
+  instructions.push(
+    await program.methods
+      .updateProxyConfigV0({
+        maxProxyTime: argv.maxProxyTime ? new anchor.BN(argv.maxProxyTime) : null,
+        seasons,
+      })
+      .accounts({
+        proxyConfig,
+        authority: proxyConfigAcc.authority,
+      })
+      .instruction()
+  );
+
+  const squads = Squads.endpoint(process.env.ANCHOR_PROVIDER_URL, wallet, {
+    commitmentOrConfig: "finalized",
+  });
+  await sendInstructionsOrSquads({
+    provider,
+    instructions,
+    executeTransaction: argv.executeTransaction,
+    squads,
+    multisig: argv.multisig ? new PublicKey(argv.multisig) : undefined,
+    authorityIndex: argv.authorityIndex,
+    signers: [],
+  });
+}

packages/helium-sub-daos-sdk/src/resolvers.ts

@@ -170,7 +170,7 @@ export const closingTimeEpochInfoResolver = resolveIndividual(
       if (positionAcc && (proxyConfigAcc || delegatedPositionAcc)) {
         const expirationTs =
           !delegatedPositionAcc || delegatedPositionAcc.expirationTs.isZero()
-            ? proxyConfigAcc?.seasons.find((s) =>
+            ? proxyConfigAcc?.seasons?.reverse().find((s) =>
                 new BN(now.toString()).gte(s.start)
               )?.end || positionAcc.lockup.endTs
             : delegatedPositionAcc.expirationTs;

packages/voter-stake-registry-hooks/src/hooks/useCreatePosition.ts

@@ -138,7 +138,7 @@ export const useCreatePosition = () => {
             registrar
           );
           const currTs = Number(unixTime) + registrarAcc.timeOffset.toNumber();
-          const endTs = proxyConfig.seasons.find(season => new BN(currTs).gte(season.start))?.end || (currTs + lockupPeriodsInDays * SECS_PER_DAY);
+          const endTs = proxyConfig.seasons.reverse().find(season => new BN(currTs).gte(season.start))?.end || (currTs + lockupPeriodsInDays * SECS_PER_DAY);
           const [subDaoEpochInfo] = subDaoEpochInfoKey(subDao.pubkey, currTs);
           const [endSubDaoEpochInfoKey] = subDaoEpochInfoKey(
             subDao.pubkey,

programs/helium-sub-daos/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "helium-sub-daos"
-version = "0.2.4"
+version = "0.2.6"
 description = "Created with Anchor"
 edition = "2021"
 

programs/helium-sub-daos/src/instructions/delegation/claim_rewards_v0.rs

@@ -60,7 +60,8 @@ pub struct ClaimRewardsV0<'info> {
   #[account(
     seeds = ["sub_dao_epoch_info".as_bytes(), sub_dao.key().as_ref(), &args.epoch.to_le_bytes()],
     bump,
-    constraint = sub_dao_epoch_info.rewards_issued_at.is_some() @ ErrorCode::EpochNotClosed
+    constraint = sub_dao_epoch_info.rewards_issued_at.is_some() @ ErrorCode::EpochNotClosed,
+    constraint = sub_dao_epoch_info.hnt_rewards_issued == 0,
   )]
   pub sub_dao_epoch_info: Box<Account<'info, SubDaoEpochInfoV0>>,
   #[account(mut)]

programs/helium-sub-daos/src/instructions/mod.rs

@@ -7,6 +7,7 @@ pub mod initialize_hnt_delegator_pool;
 pub mod initialize_sub_dao_v0;
 pub mod issue_rewards_v0;
 pub mod switch_mobile_ops_fund;
+pub mod temp_fix_claimed_epoch;
 pub mod temp_resize_account;
 pub mod temp_update_sub_dao_epoch_info;
 pub mod track_dc_burn_v0;
@@ -24,6 +25,7 @@ pub use initialize_hnt_delegator_pool::*;
 pub use initialize_sub_dao_v0::*;
 pub use issue_rewards_v0::*;
 pub use switch_mobile_ops_fund::*;
+pub use temp_fix_claimed_epoch::*;
 pub use temp_resize_account::*;
 pub use temp_update_sub_dao_epoch_info::*;
 pub use track_dc_burn_v0::*;

programs/helium-sub-daos/src/instructions/temp_fix_claimed_epoch.rs

@@ -0,0 +1,23 @@
+use std::str::FromStr;
+
+use anchor_lang::prelude::*;
+
+use crate::DelegatedPositionV0;
+
+#[derive(Accounts)]
+pub struct TempFixClaimedEpoch<'info> {
+  #[account(
+    mut,
+    address = Pubkey::from_str("hprdnjkbziK8NqhThmAn5Gu4XqrBbctX8du4PfJdgvW").unwrap()
+  )]
+  pub authority: Signer<'info>,
+  #[account(mut)]
+  pub delegated_position: Account<'info, DelegatedPositionV0>,
+  pub system_program: Program<'info, System>,
+}
+
+pub fn handler(ctx: Context<TempFixClaimedEpoch>) -> Result<()> {
+  ctx.accounts.delegated_position.set_unclaimed(20117)?;
+
+  Ok(())
+}

programs/helium-sub-daos/src/lib.rs

@@ -147,4 +147,8 @@ pub mod helium_sub_daos {
   pub fn track_vote_v0(ctx: Context<TrackVoteV0>) -> Result<()> {
     track_vote_v0::handler(ctx)
   }
+
+  pub fn temp_fix_claimed_epoch(ctx: Context<TempFixClaimedEpoch>) -> Result<()> {
+    temp_fix_claimed_epoch::handler(ctx)
+  }
 }

programs/helium-sub-daos/src/state.rs

@@ -231,6 +231,21 @@ impl DelegatedPositionV0 {
     }
   }
 
+  pub fn set_unclaimed(&mut self, epoch: u64) -> Result<()> {
+    while epoch <= self.last_claimed_epoch {
+      self.last_claimed_epoch -= 1;
+      if self.claimed_epochs_bitmap & 1 != 0 {
+        return Err(error!(ErrorCode::InvalidClaimEpoch));
+      }
+      self.claimed_epochs_bitmap >>= 1;
+    }
+
+    let bit_index = (epoch - self.last_claimed_epoch - 1) as u128;
+    // Clear the bit at bit_index
+    self.claimed_epochs_bitmap &= !(1_u128 << (127_u128 - bit_index));
+    Ok(())
+  }
+
   // Add a proposal to the recent proposals list
   pub fn add_recent_proposal(&mut self, proposal: Pubkey, ts: i64) {
     let new_proposal = RecentProposal { proposal, ts };
@@ -341,4 +356,33 @@ mod tests {
     assert_eq!(position.last_claimed_epoch, 2);
     assert_eq!(position.claimed_epochs_bitmap, 0);
   }
+
+  #[test]
+  fn test_unclaimed() {
+    let mut position = DelegatedPositionV0::default();
+    let epoch = 1;
+
+    // First claim the epoch
+    position.set_claimed(epoch).unwrap();
+    assert!(position.is_claimed(epoch).unwrap());
+    assert!(position.last_claimed_epoch == 1);
+
+    // Then unclaim it
+    position.set_unclaimed(epoch).unwrap();
+    assert!(!position.is_claimed(epoch).unwrap());
+    assert!(!position.is_claimed(epoch + 1).unwrap());
+    assert!(position.last_claimed_epoch == 0);
+    assert!(position.claimed_epochs_bitmap == 0);
+
+    let epoch = 2;
+    position.set_claimed(epoch).unwrap();
+    assert!(position.is_claimed(epoch).unwrap());
+    assert!(position.last_claimed_epoch == 0);
+
+    // Then unclaim it
+    position.set_unclaimed(epoch).unwrap();
+    assert!(!position.is_claimed(epoch).unwrap());
+    assert!(position.last_claimed_epoch == 0);
+    assert!(position.claimed_epochs_bitmap == 0);
+  }
 }