@ghostspeak/sdk 2.0.6 → 2.0.8

package/dist/{chunk-F3DZMBUA.js → chunk-5QBSC4T4.js}

@@ -1,10 +1,10 @@
-import { encryptAmount, serializeCiphertext, generateRangeProof, generateValidityProof, generateEqualityProof, generateElGamalKeypair, decryptAmount } from './chunk-IAWBZYPE.js';
-import { TOKEN_PROGRAM_ADDRESS, ASSOCIATED_TOKEN_PROGRAM_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS } from './chunk-OWYHJG6H.js';
-import { AGENT_DISCRIMINATOR } from './chunk-GMHIUK2R.js';
-import { __export } from './chunk-NSBPE2FW.js';
-import { fetchEncodedAccount, getAddressEncoder, getU64Encoder, getBytesEncoder, getUtf8Encoder, getProgramDerivedAddress } from '@solana/kit';
+import { TOKEN_PROGRAM_ADDRESS, ASSOCIATED_TOKEN_PROGRAM_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS } from './chunk-OXA7MECJ.js';
+import { AGENT_DISCRIMINATOR } from './chunk-5QZVFUXB.js';
+import { __export } from './chunk-UP2VWCW5.js';
+import { fetchEncodedAccount, getProgramDerivedAddress, getBytesEncoder, getAddressEncoder } from '@solana/kit';
 import { sha256 } from '@noble/hashes/sha256';
-import { bytesToHex, randomBytes } from '@noble/curves/abstract/utils';
+import { randomBytes, bytesToNumberLE, bytesToHex } from '@noble/curves/abstract/utils';
+import { ed25519 } from '@noble/curves/ed25519';
 
 // src/utils/discriminator-validator.ts
 function validateAccountDiscriminator(accountData, expectedDiscriminator) {
@@ -72,7 +72,7 @@ function createDiscriminatorErrorMessage(validation, accountType, address) {
 }
 async function safeDecodeAgent(encodedAccount) {
   try {
-    const { AGENT_DISCRIMINATOR: AGENT_DISCRIMINATOR2, getAgentDecoder } = await import('./agent-M74TCRON.js');
+    const { AGENT_DISCRIMINATOR: AGENT_DISCRIMINATOR2, getAgentDecoder } = await import('./agent-S42FIMR7.js');
     const validation = validateAccountDiscriminator(encodedAccount.data, AGENT_DISCRIMINATOR2);
     if (validation.canDecode) {
       try {
@@ -131,7 +131,7 @@ async function createMigrationPlan(encodedAccount, address) {
     plan.recommendations.push("Account does not exist - no migration needed");
     return plan;
   }
-  const { AGENT_DISCRIMINATOR: AGENT_DISCRIMINATOR2 } = await import('./agent-M74TCRON.js');
+  const { AGENT_DISCRIMINATOR: AGENT_DISCRIMINATOR2 } = await import('./agent-S42FIMR7.js');
   const validation = validateAccountDiscriminator(encodedAccount.data, AGENT_DISCRIMINATOR2);
   const inspection = inspectAccountData(encodedAccount, address);
   if (validation.isValid) {
@@ -306,7 +306,7 @@ async function runAccountDiagnostics(encodedAccount, address) {
   const accountExists = "exists" in encodedAccount && encodedAccount.exists;
   let discriminatorValidation, inspection, migrationPlan, migrationSimulation;
   if (accountExists) {
-    const { AGENT_DISCRIMINATOR: AGENT_DISCRIMINATOR2 } = await import('./agent-M74TCRON.js');
+    const { AGENT_DISCRIMINATOR: AGENT_DISCRIMINATOR2 } = await import('./agent-S42FIMR7.js');
     discriminatorValidation = validateAccountDiscriminator(encodedAccount.data, AGENT_DISCRIMINATOR2);
     inspection = inspectAccountData(encodedAccount, address);
     migrationPlan = await createMigrationPlan(encodedAccount, address);
@@ -680,71 +680,13 @@ async function getTokenProgramType(mint) {
   const isToken2022 = await isToken2022Mint(mint);
   return isToken2022 ? "token-2022" /* TOKEN_2022 */ : "spl-token" /* SPL_TOKEN */;
 }
-async function checkToken2022Extensions(mint, extensions, rpcEndpoint = "https://api.devnet.solana.com") {
-  try {
-    const { getMintWithExtensions } = await import('./token-2022-rpc-RALH4RK7.js');
-    const { createSolanaRpc } = await import('@solana/kit');
-    const rpc = createSolanaRpc(rpcEndpoint);
-    const mintData = await getMintWithExtensions(rpc, mint, "confirmed");
-    if (!mintData) {
-      const result2 = {};
-      for (const extension of extensions) {
-        result2[extension] = false;
-      }
-      return result2;
-    }
-    const result = {};
-    for (const extension of extensions) {
-      switch (extension) {
-        case 1 /* TRANSFER_FEE_CONFIG */:
-          result[extension] = Boolean(mintData.extensions.transferFeeConfig);
-          break;
-        case 3 /* MINT_CLOSE_AUTHORITY */:
-          result[extension] = Boolean(mintData.extensions.mintCloseAuthority);
-          break;
-        case 4 /* CONFIDENTIAL_TRANSFER_MINT */:
-          result[extension] = Boolean(mintData.extensions.confidentialTransferMint);
-          break;
-        case 6 /* DEFAULT_ACCOUNT_STATE */:
-          result[extension] = Boolean(mintData.extensions.defaultAccountState);
-          break;
-        case 9 /* NON_TRANSFERABLE */:
-          result[extension] = Boolean(mintData.extensions.nonTransferable);
-          break;
-        case 10 /* INTEREST_BEARING_MINT */:
-          result[extension] = Boolean(mintData.extensions.interestBearingConfig);
-          break;
-        case 12 /* PERMANENT_DELEGATE */:
-          result[extension] = Boolean(mintData.extensions.permanentDelegate);
-          break;
-        case 14 /* TRANSFER_HOOK */:
-          result[extension] = Boolean(mintData.extensions.transferHook);
-          break;
-        case 16 /* METADATA_POINTER */:
-          result[extension] = Boolean(mintData.extensions.metadataPointer);
-          break;
-        case 17 /* TOKEN_METADATA */:
-          result[extension] = Boolean(mintData.extensions.tokenMetadata);
-          break;
-        case 18 /* GROUP_POINTER */:
-          result[extension] = Boolean(mintData.extensions.groupPointer);
-          break;
-        case 19 /* TOKEN_GROUP */:
-          result[extension] = Boolean(mintData.extensions.tokenGroup);
-          break;
-        default:
-          result[extension] = false;
-      }
-    }
-    return result;
-  } catch (error) {
-    console.error(`Failed to check Token-2022 extensions for mint ${mint}:`, error);
-    const result = {};
-    for (const extension of extensions) {
-      result[extension] = false;
-    }
-    return result;
+async function checkToken2022Extensions(mint, extensions, _rpcEndpoint = "https://api.devnet.solana.com") {
+  console.warn(`Token-2022 extension checking is deprecated: mint ${mint}`);
+  const result = {};
+  for (const extension of extensions) {
+    result[extension] = false;
   }
+  return result;
 }
 async function hasTransferFeeExtension(mint, rpcEndpoint = "https://api.devnet.solana.com") {
   const result = await checkToken2022Extensions(
@@ -770,79 +712,17 @@ async function hasInterestBearingExtension(mint, rpcEndpoint = "https://api.devn
   );
   return result[10 /* INTEREST_BEARING_MINT */];
 }
-async function getTransferFeeConfig(mint, rpcEndpoint = "https://api.devnet.solana.com") {
-  try {
-    const { getMintWithExtensions } = await import('./token-2022-rpc-RALH4RK7.js');
-    const { createSolanaRpc } = await import('@solana/kit');
-    const rpc = createSolanaRpc(rpcEndpoint);
-    const mintData = await getMintWithExtensions(rpc, mint, "confirmed");
-    if (!mintData?.extensions.transferFeeConfig) {
-      return null;
-    }
-    const config = mintData.extensions.transferFeeConfig;
-    return {
-      transferFeeBasisPoints: config.newerTransferFee.transferFeeBasisPoints,
-      maximumFee: config.newerTransferFee.maximumFee,
-      transferFeeConfigAuthority: config.transferFeeConfigAuthority,
-      withdrawWithheldAuthority: config.withdrawWithheldAuthority,
-      withheldAmount: BigInt(0),
-      olderTransferFee: {
-        epoch: config.olderTransferFee.epoch || BigInt(0),
-        transferFeeBasisPoints: config.olderTransferFee.transferFeeBasisPoints || 0,
-        maximumFee: config.olderTransferFee.maximumFee || BigInt(0)
-      },
-      newerTransferFee: {
-        epoch: config.newerTransferFee.epoch,
-        transferFeeBasisPoints: config.newerTransferFee.transferFeeBasisPoints,
-        maximumFee: config.newerTransferFee.maximumFee
-      }
-    };
-  } catch (error) {
-    console.error(`Failed to get transfer fee config for mint ${mint}:`, error);
-    return null;
-  }
+async function getTransferFeeConfig(mint, _rpcEndpoint = "https://api.devnet.solana.com") {
+  console.warn(`Token-2022 getTransferFeeConfig is deprecated: mint ${mint}`);
+  return null;
 }
-async function getConfidentialTransferConfig(mint, rpcEndpoint = "https://api.devnet.solana.com") {
-  try {
-    const { getMintWithExtensions } = await import('./token-2022-rpc-RALH4RK7.js');
-    const { createSolanaRpc } = await import('@solana/kit');
-    const rpc = createSolanaRpc(rpcEndpoint);
-    const mintData = await getMintWithExtensions(rpc, mint, "confirmed");
-    if (!mintData?.extensions.confidentialTransferMint) {
-      return null;
-    }
-    const config = mintData.extensions.confidentialTransferMint;
-    return {
-      authority: config.authority,
-      autoApproveNewAccounts: config.autoApproveNewAccounts,
-      auditorElgamalPubkey: config.auditorElgamalPubkey
-    };
-  } catch (error) {
-    console.error(`Failed to get confidential transfer config for mint ${mint}:`, error);
-    return null;
-  }
+async function getConfidentialTransferConfig(mint, _rpcEndpoint = "https://api.devnet.solana.com") {
+  console.warn(`Token-2022 getConfidentialTransferConfig is deprecated: mint ${mint}`);
+  return null;
 }
-async function getInterestBearingConfig(mint, rpcEndpoint = "https://api.devnet.solana.com") {
-  try {
-    const { getMintWithExtensions } = await import('./token-2022-rpc-RALH4RK7.js');
-    const { createSolanaRpc } = await import('@solana/kit');
-    const rpc = createSolanaRpc(rpcEndpoint);
-    const mintData = await getMintWithExtensions(rpc, mint, "confirmed");
-    if (!mintData?.extensions.interestBearingConfig) {
-      return null;
-    }
-    const config = mintData.extensions.interestBearingConfig;
-    return {
-      rateAuthority: config.rateAuthority,
-      currentRate: config.currentRate,
-      initializationTimestamp: config.initializationTimestamp || BigInt(Math.floor(Date.now() / 1e3)),
-      lastUpdateTimestamp: config.lastUpdateTimestamp,
-      preUpdateAverageRate: config.preUpdateAverageRate
-    };
-  } catch (error) {
-    console.error(`Failed to get interest-bearing config for mint ${mint}:`, error);
-    return null;
-  }
+async function getInterestBearingConfig(mint, _rpcEndpoint = "https://api.devnet.solana.com") {
+  console.warn(`Token-2022 getInterestBearingConfig is deprecated: mint ${mint}`);
+  return null;
 }
 async function getAllAssociatedTokenAddresses(owner, mint) {
   const [splToken, token2022] = await Promise.all([
@@ -898,373 +778,264 @@ function parseTokenAmount(formatted, decimals) {
   return BigInt(rawAmount);
 }
 
-// src/utils/token-2022-extensions.ts
-var token_2022_extensions_exports = {};
-__export(token_2022_extensions_exports, {
-  TokenAccountState: () => TokenAccountState,
-  basisPointsToPercentage: () => basisPointsToPercentage,
-  calculateCompoundInterest: () => calculateCompoundInterest,
-  calculateInterest: () => calculateInterest,
-  calculateRequiredAmountForNetTransfer: () => calculateRequiredAmountForNetTransfer,
-  calculateTransferFee: () => calculateTransferFee,
-  canTransfer: () => canTransfer,
-  createInterestBearingConfig: () => createInterestBearingConfig,
-  createTransferFeeConfig: () => createTransferFeeConfig,
-  createTransferHookInstruction: () => createTransferHookInstruction,
-  deserializeTokenMetadata: () => deserializeTokenMetadata,
-  estimateAccumulatedFees: () => estimateAccumulatedFees,
-  estimateComputeUnits: () => estimateComputeUnits,
-  formatBasisPoints: () => formatBasisPoints,
-  generateConfidentialTransferProof: () => generateConfidentialTransferProof,
-  getRequiredExtensions: () => getRequiredExtensions,
-  parseTokenExtension: () => parseTokenExtension,
-  percentageToBasisPoints: () => percentageToBasisPoints,
-  serializeTokenMetadata: () => serializeTokenMetadata,
-  validateTransferHookInstruction: () => validateTransferHookInstruction,
-  verifyConfidentialTransferProof: () => verifyConfidentialTransferProof
+// src/utils/governance-helpers.ts
+var governance_helpers_exports = {};
+__export(governance_helpers_exports, {
+  GovernanceAnalyticsUtils: () => GovernanceAnalyticsUtils,
+  PERMISSION_TEMPLATES: () => PERMISSION_TEMPLATES,
+  ProposalUtils: () => ProposalUtils,
+  ROLE_TEMPLATES: () => ROLE_TEMPLATES,
+  VotingUtils: () => VotingUtils,
+  deriveMultisigPda: () => deriveMultisigPda,
+  deriveProposalPda: () => deriveProposalPda,
+  deriveRbacPda: () => deriveRbacPda
 });
-function calculateTransferFee(transferAmount, feeConfig) {
-  const { transferFeeBasisPoints, maximumFee } = feeConfig;
-  const calculatedFee = transferAmount * BigInt(transferFeeBasisPoints) / 10000n;
-  const feeAmount = calculatedFee > maximumFee ? maximumFee : calculatedFee;
-  const wasFeeCapped = calculatedFee > maximumFee;
-  const netAmount = transferAmount - feeAmount;
-  return {
-    transferAmount,
-    feeAmount,
-    netAmount,
-    feeBasisPoints: transferFeeBasisPoints,
-    wasFeeCapped
-  };
+async function deriveMultisigPda(programId, authority, multisigId) {
+  const [pda] = await getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [
+      getBytesEncoder().encode(new Uint8Array([109, 117, 108, 116, 105, 115, 105, 103])),
+      // 'multisig'
+      getAddressEncoder().encode(authority),
+      new Uint8Array(new BigUint64Array([multisigId]).buffer)
+    ]
+  });
+  return pda;
 }
-function calculateRequiredAmountForNetTransfer(desiredNetAmount, feeConfig) {
-  const { transferFeeBasisPoints } = feeConfig;
-  const grossAmount = desiredNetAmount * 10000n / (10000n - BigInt(transferFeeBasisPoints));
-  return calculateTransferFee(grossAmount, feeConfig);
+async function deriveProposalPda(programId, multisig, proposalId) {
+  const [pda] = await getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [
+      getBytesEncoder().encode(new Uint8Array([112, 114, 111, 112, 111, 115, 97, 108])),
+      // 'proposal'
+      getAddressEncoder().encode(multisig),
+      new Uint8Array(new BigUint64Array([proposalId]).buffer)
+    ]
+  });
+  return pda;
 }
-function estimateAccumulatedFees(transfers, feeConfig) {
-  const feeBreakdown = [];
-  let totalFees = 0n;
-  for (const transferAmount of transfers) {
-    const calculation = calculateTransferFee(transferAmount, feeConfig);
-    feeBreakdown.push(calculation);
-    totalFees += calculation.feeAmount;
-  }
-  return { totalFees, feeBreakdown };
+async function deriveRbacPda(programId, admin) {
+  const [pda] = await getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [
+      getBytesEncoder().encode(new Uint8Array([114, 98, 97, 99])),
+      // 'rbac'
+      getAddressEncoder().encode(admin)
+    ]
+  });
+  return pda;
 }
-async function generateConfidentialTransferProof(amount, senderKeypair, recipientPubkey, auditorPubkey) {
-  const recipientCiphertext = encryptAmount(amount, recipientPubkey);
-  const encryptedAmount = serializeCiphertext(recipientCiphertext);
-  const randomness = new Uint8Array(32);
-  crypto.getRandomValues(randomness);
-  const rangeProof = await generateRangeProof(
-    amount,
-    recipientCiphertext.commitment,
-    randomness
-  );
-  const validityProof = await generateValidityProof(
-    recipientCiphertext,
-    recipientPubkey,
-    randomness
-  );
-  let auditorProof;
-  if (auditorPubkey) {
-    const auditorCiphertext = encryptAmount(amount, auditorPubkey);
-    const auditorRandomness = new Uint8Array(32);
-    crypto.getRandomValues(auditorRandomness);
-    const equalityProof = generateEqualityProof(
-      recipientCiphertext,
-      auditorCiphertext,
-      randomness,
-      auditorRandomness
-    );
-    auditorProof = new Uint8Array(160);
-    auditorProof.set(serializeCiphertext(auditorCiphertext), 0);
-    auditorProof.set(equalityProof.proof, 64);
+var ProposalUtils = class {
+  /**
+   * Check if proposal is in voting period
+   */
+  static isVotingOpen(proposal) {
+    const now = BigInt(Math.floor(Date.now() / 1e3));
+    return proposal.status === 1 /* Active */ && now >= proposal.votingStartsAt && now <= proposal.votingEndsAt;
   }
-  return {
-    encryptedAmount,
-    rangeProof: rangeProof.proof,
-    validityProof: validityProof.proof,
-    auditorProof
-  };
-}
-async function verifyConfidentialTransferProof(proof, publicInputs) {
-  try {
-    if (proof.encryptedAmount.length !== 64) {
-      return false;
-    }
-    if (proof.rangeProof.length < 128) {
-      return false;
+  /**
+   * Check if proposal has expired
+   */
+  static hasExpired(proposal) {
+    const now = BigInt(Math.floor(Date.now() / 1e3));
+    return now > proposal.votingEndsAt;
+  }
+  /**
+   * Calculate time remaining for voting
+   */
+  static timeRemaining(proposal) {
+    const now = BigInt(Math.floor(Date.now() / 1e3));
+    if (now >= proposal.votingEndsAt) return 0n;
+    return proposal.votingEndsAt - now;
+  }
+  /**
+   * Format time remaining as human-readable string
+   */
+  static formatTimeRemaining(proposal) {
+    const remaining = this.timeRemaining(proposal);
+    if (remaining === 0n) return "Voting ended";
+    const seconds = Number(remaining);
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor(seconds % 86400 / 3600);
+    const minutes = Math.floor(seconds % 3600 / 60);
+    if (days > 0) return `${days}d ${hours}h remaining`;
+    if (hours > 0) return `${hours}h ${minutes}m remaining`;
+    return `${minutes}m remaining`;
+  }
+  /**
+   * Calculate if proposal has reached quorum
+   */
+  static hasReachedQuorum(votingResults, quorumRequirements, totalEligibleVoters) {
+    const totalVotes = Number(votingResults.votesFor + votingResults.votesAgainst + votingResults.votesAbstain);
+    const participationRate = totalVotes / totalEligibleVoters * 100;
+    return participationRate >= quorumRequirements.minimumParticipation;
+  }
+  /**
+   * Calculate voting results summary
+   */
+  static calculateResults(votingResults) {
+    const total = Number(votingResults.votesFor + votingResults.votesAgainst + votingResults.votesAbstain);
+    if (total === 0) {
+      return {
+        total: 0,
+        forPercentage: 0,
+        againstPercentage: 0,
+        abstainPercentage: 0,
+        passed: false
+      };
     }
-    if (proof.validityProof.length < 64) {
-      return false;
+    const forPercentage = Number(votingResults.votesFor) / total * 100;
+    const againstPercentage = Number(votingResults.votesAgainst) / total * 100;
+    const abstainPercentage = Number(votingResults.votesAbstain) / total * 100;
+    const passed = votingResults.votesFor > votingResults.votesAgainst;
+    return {
+      total,
+      forPercentage,
+      againstPercentage,
+      abstainPercentage,
+      passed
+    };
+  }
+  /**
+   * Validate proposal
+   */
+  static validateProposal(proposal) {
+    if (!proposal.title || proposal.title.trim().length === 0) {
+      return { valid: false, error: "Title is required" };
     }
-    if (publicInputs.auditorPubkey && !proof.auditorProof) {
-      return false;
+    if (proposal.title.length > 100) {
+      return { valid: false, error: "Title cannot exceed 100 characters" };
     }
-    if (proof.auditorProof && proof.auditorProof.length !== 160) {
-      return false;
+    if (!proposal.description || proposal.description.trim().length === 0) {
+      return { valid: false, error: "Description is required" };
     }
-    const {
-      verifyRangeProof,
-      verifyValidityProof,
-      verifyEqualityProof,
-      deserializeCiphertext
-    } = await import('./elgamal-VZLWB3XK.js');
-    const encryptedAmountCiphertext = deserializeCiphertext(proof.encryptedAmount);
-    const rangeProofValid = await verifyRangeProof(
-      { proof: proof.rangeProof, commitment: encryptedAmountCiphertext.commitment.commitment },
-      encryptedAmountCiphertext.commitment.commitment
-    );
-    if (!rangeProofValid) {
-      return false;
+    if (proposal.description.length > 5e3) {
+      return { valid: false, error: "Description cannot exceed 5000 characters" };
     }
-    const validityProofValid = verifyValidityProof(
-      { proof: proof.validityProof },
-      encryptedAmountCiphertext,
-      publicInputs.recipientPubkey
-    );
-    if (!validityProofValid) {
-      return false;
+    return { valid: true };
+  }
+};
+var VotingUtils = class {
+  /**
+   * Calculate vote weight based on token holdings or other factors
+   */
+  static calculateVoteWeight(baseWeight, tokenBalance, stakeDuration) {
+    let weight = baseWeight;
+    if (tokenBalance) {
+      const tokenMultiplier = Math.min(Number(tokenBalance / 1000000n), 10);
+      weight *= tokenMultiplier;
     }
-    if (proof.auditorProof && publicInputs.auditorPubkey) {
-      const auditorCiphertext = deserializeCiphertext(proof.auditorProof.slice(0, 64));
-      const equalityProofData = proof.auditorProof.slice(64);
-      const equalityProofValid = verifyEqualityProof(
-        { proof: equalityProofData },
-        encryptedAmountCiphertext,
-        auditorCiphertext
-      );
-      if (!equalityProofValid) {
-        return false;
-      }
+    if (stakeDuration) {
+      const daysStaked = Number(stakeDuration / 86400n);
+      const timeMultiplier = 1 + daysStaked / 365;
+      weight *= timeMultiplier;
     }
-    return true;
-  } catch {
-    return false;
+    return Math.floor(weight);
   }
-}
-function calculateInterest(principal, config, currentTimestamp) {
-  const timePeriodSeconds = currentTimestamp - config.lastUpdateTimestamp;
-  const secondsPerYear = 365n * 24n * 60n * 60n;
-  const rateBasisPoints = BigInt(config.currentRate);
-  const interestAmount = principal * rateBasisPoints * timePeriodSeconds / (10000n * secondsPerYear);
-  const newBalance = principal + interestAmount;
-  const yearFraction = Number(timePeriodSeconds) / Number(secondsPerYear);
-  const effectiveAnnualRate = config.currentRate / 100 * yearFraction;
-  return {
-    principal,
-    annualRateBasisPoints: config.currentRate,
-    timePeriodSeconds,
-    interestAmount,
-    newAmount: newBalance,
-    effectiveAnnualRate
-  };
-}
-function calculateCompoundInterest(principal, annualRateBasisPoints, compoundingPeriodsPerYear, years) {
-  const rate = annualRateBasisPoints / 1e4;
-  const n = compoundingPeriodsPerYear;
-  const compoundFactor = Math.pow(1 + rate / n, n * years);
-  const newBalanceFloat = Number(principal) * compoundFactor;
-  const newBalance = BigInt(Math.floor(newBalanceFloat));
-  const interestAmount = newBalance - principal;
-  const timePeriodSeconds = BigInt(Math.floor(years * 365 * 24 * 60 * 60));
-  return {
-    principal,
-    annualRateBasisPoints,
-    timePeriodSeconds,
-    interestAmount,
-    newAmount: newBalance,
-    effectiveAnnualRate: (compoundFactor - 1) * 100
-  };
-}
-function validateTransferHookInstruction(instruction) {
-  if (!instruction.programId) return false;
-  if (!Array.isArray(instruction.additionalAccounts)) return false;
-  return true;
-}
-function createTransferHookInstruction(hookProgramId, context) {
-  const instructionData = new Uint8Array([
-    ...getAddressEncoder().encode(context.source),
-    ...getAddressEncoder().encode(context.destination),
-    ...getAddressEncoder().encode(context.authority),
-    ...getU64Encoder().encode(context.amount),
-    ...getAddressEncoder().encode(context.mint),
-    ...getBytesEncoder().encode(context.contextData)
-  ]);
-  return {
-    programId: hookProgramId,
-    instructionData,
-    additionalAccounts: []
-    // Hook-specific accounts would be added here
-  };
-}
-function serializeTokenMetadata(metadata) {
-  const jsonString = JSON.stringify(metadata);
-  const encoded = getUtf8Encoder().encode(jsonString);
-  return new Uint8Array(encoded);
-}
-function deserializeTokenMetadata(data) {
-  const jsonString = new TextDecoder().decode(data);
-  return JSON.parse(jsonString);
-}
-var TokenAccountState = /* @__PURE__ */ ((TokenAccountState2) => {
-  TokenAccountState2[TokenAccountState2["UNINITIALIZED"] = 0] = "UNINITIALIZED";
-  TokenAccountState2[TokenAccountState2["INITIALIZED"] = 1] = "INITIALIZED";
-  TokenAccountState2[TokenAccountState2["FROZEN"] = 2] = "FROZEN";
-  return TokenAccountState2;
-})(TokenAccountState || {});
-function canTransfer(state, isNonTransferable = false, isFrozen = false) {
-  if (state !== 1 /* INITIALIZED */) return false;
-  if (isNonTransferable) return false;
-  if (isFrozen) return false;
-  return true;
-}
-function getRequiredExtensions(extensions) {
-  const required = /* @__PURE__ */ new Set();
-  for (const extension of extensions) {
-    required.add(extension);
-    switch (extension) {
-      case 2 /* TRANSFER_FEE_AMOUNT */:
-        required.add(1 /* TRANSFER_FEE_CONFIG */);
-        break;
-      case 5 /* CONFIDENTIAL_TRANSFER_ACCOUNT */:
-        required.add(4 /* CONFIDENTIAL_TRANSFER_MINT */);
-        break;
-      case 15 /* TRANSFER_HOOK_ACCOUNT */:
-        required.add(14 /* TRANSFER_HOOK */);
-        break;
+  /**
+   * Format vote choice as string
+   */
+  static formatVoteChoice(voteChoice) {
+    switch (voteChoice) {
+      case 0 /* For */:
+        return "\u2705 For";
+      case 1 /* Against */:
+        return "\u274C Against";
+      case 2 /* Abstain */:
+        return "\u{1F937} Abstain";
+      default:
+        return "Unknown";
     }
   }
-  return Array.from(required).sort((a, b) => a - b);
-}
-function basisPointsToPercentage(basisPoints) {
-  return basisPoints / 1e4;
-}
-function percentageToBasisPoints(percentage) {
-  return Math.round(percentage * 1e4);
-}
-function formatBasisPoints(basisPoints) {
-  const percentage = basisPointsToPercentage(basisPoints) * 100;
-  return `${percentage.toFixed(2)}%`;
-}
-function estimateComputeUnits(operation, extensions = []) {
-  let baseUnits = 0n;
-  switch (operation) {
-    case "transfer":
-      baseUnits = 15000n;
-      break;
-    case "create_account":
-      baseUnits = 25000n;
-      break;
-    case "mint":
-      baseUnits = 10000n;
-      break;
-    case "burn":
-      baseUnits = 10000n;
-      break;
+  /**
+   * Calculate if simple majority is reached
+   */
+  static hasSimpleMajority(votingResults) {
+    return votingResults.votesFor > votingResults.votesAgainst;
   }
-  let extensionUnits = 0n;
-  for (const extension of extensions) {
-    switch (extension) {
-      case 1 /* TRANSFER_FEE_CONFIG */:
-        extensionUnits += 5000n;
-        break;
-      case 4 /* CONFIDENTIAL_TRANSFER_MINT */:
-      case 5 /* CONFIDENTIAL_TRANSFER_ACCOUNT */:
-        extensionUnits += 50000n;
-        break;
-      case 14 /* TRANSFER_HOOK */:
-        extensionUnits += 15000n;
-        break;
-      default:
-        extensionUnits += 2000n;
-    }
+  /**
+   * Calculate if supermajority is reached (2/3)
+   */
+  static hasSupermajority(votingResults) {
+    const totalVotes = votingResults.votesFor + votingResults.votesAgainst;
+    if (totalVotes === 0n) return false;
+    const forPercentage = Number(votingResults.votesFor) / Number(totalVotes);
+    return forPercentage >= 0.667;
   }
-  return baseUnits + extensionUnits;
-}
-function createTransferFeeConfig(params) {
-  if (params.transferFeeBasisPoints > 1e4) {
-    throw new Error("Transfer fee basis points cannot exceed 10000");
+};
+var PERMISSION_TEMPLATES = {
+  // Admin permissions
+  ADMIN: {
+    CREATE_PROPOSAL: { action: "create", resource: "proposal" },
+    EXECUTE_PROPOSAL: { action: "execute", resource: "proposal" },
+    MANAGE_ROLES: { action: "manage", resource: "roles" },
+    MANAGE_TREASURY: { action: "manage", resource: "treasury" }
+  },
+  // Member permissions
+  MEMBER: {
+    VOTE: { action: "vote", resource: "proposal" },
+    VIEW: { action: "view", resource: "all" },
+    COMMENT: { action: "comment", resource: "proposal" }
+  },
+  // Moderator permissions
+  MODERATOR: {
+    CANCEL_PROPOSAL: { action: "cancel", resource: "proposal" },
+    MODERATE_COMMENTS: { action: "moderate", resource: "comments" },
+    VIEW_REPORTS: { action: "view", resource: "reports" }
   }
-  return {
-    transferFeeBasisPoints: params.transferFeeBasisPoints,
-    maximumFee: params.maximumFee,
-    transferFeeConfigAuthority: params.transferFeeConfigAuthority,
-    withdrawWithheldAuthority: params.withdrawWithheldAuthority,
-    withheldAmount: BigInt(0),
-    olderTransferFee: {
-      epoch: BigInt(0),
-      transferFeeBasisPoints: 0,
-      maximumFee: BigInt(0)
-    },
-    newerTransferFee: {
-      epoch: BigInt(1),
-      transferFeeBasisPoints: params.transferFeeBasisPoints,
-      maximumFee: params.maximumFee
-    }
-  };
-}
-function createInterestBearingConfig(params) {
-  if (params.currentRate > 32767 || params.currentRate < -32768) {
-    throw new Error("Interest rate must be within i16 range");
+};
+var ROLE_TEMPLATES = {
+  ADMIN: {
+    name: "Administrator",
+    description: "Full administrative access",
+    permissions: Object.values(PERMISSION_TEMPLATES.ADMIN)
+  },
+  MEMBER: {
+    name: "Member",
+    description: "Standard member access",
+    permissions: Object.values(PERMISSION_TEMPLATES.MEMBER)
+  },
+  MODERATOR: {
+    name: "Moderator",
+    description: "Content moderation access",
+    permissions: [
+      ...Object.values(PERMISSION_TEMPLATES.MEMBER),
+      ...Object.values(PERMISSION_TEMPLATES.MODERATOR)
+    ]
   }
-  const currentTimestamp = BigInt(Math.floor(Date.now() / 1e3));
-  return {
-    rateAuthority: params.rateAuthority,
-    initializationTimestamp: currentTimestamp,
-    preUpdateAverageRate: 0,
-    lastUpdateTimestamp: currentTimestamp,
-    currentRate: params.currentRate
-  };
-}
-function parseTokenExtension(extensionType, data) {
-  switch (extensionType) {
-    case "TransferFeeConfig": {
-      if (data.length < 108) {
-        throw new Error("Invalid extension data length");
-      }
-      const transferFeeBasisPoints = data[0] | data[1] << 8;
-      return {
-        transferFeeBasisPoints,
-        maximumFee: BigInt(0),
-        // Would parse from bytes 2-9
-        transferFeeConfigAuthority: null,
-        withdrawWithheldAuthority: null,
-        withheldAmount: BigInt(0),
-        olderTransferFee: {
-          epoch: BigInt(0),
-          transferFeeBasisPoints: 0,
-          maximumFee: BigInt(0)
-        },
-        newerTransferFee: {
-          epoch: BigInt(1),
-          transferFeeBasisPoints,
-          maximumFee: BigInt(0)
-        }
-      };
-    }
-    case "InterestBearingConfig": {
-      if (data.length < 40) {
-        throw new Error("Invalid extension data length");
-      }
-      let timestamp = 0n;
-      for (let i = 0; i < 8; i++) {
-        timestamp |= BigInt(data[i]) << BigInt(i * 8);
-      }
-      return {
-        rateAuthority: null,
-        initializationTimestamp: timestamp,
-        preUpdateAverageRate: 0,
-        lastUpdateTimestamp: timestamp,
-        currentRate: 0
-      };
+};
+var GovernanceAnalyticsUtils = class {
+  /**
+   * Calculate governance health score (0-100)
+   */
+  static calculateHealthScore(analytics) {
+    let score = 0;
+    score += Math.min(analytics.averageVoterTurnout * 0.4, 40);
+    const totalCompleted = analytics.passedProposals + analytics.failedProposals;
+    if (totalCompleted > 0) {
+      const successRate = analytics.passedProposals / totalCompleted;
+      score += successRate * 30;
     }
-    default:
-      throw new Error("Unknown extension type");
+    const activityRatio = analytics.activeProposals / Math.max(analytics.totalProposals, 1);
+    score += Math.min(activityRatio * 60, 30);
+    return Math.round(score);
   }
-}
+  /**
+   * Generate governance summary report
+   */
+  static generateSummaryReport(analytics) {
+    const healthScore = this.calculateHealthScore(analytics);
+    const successRate = analytics.totalProposals > 0 ? Math.round(analytics.passedProposals / analytics.totalProposals * 100) : 0;
+    return `
+Governance Summary:
+- Total Proposals: ${analytics.totalProposals}
+- Active: ${analytics.activeProposals}
+- Success Rate: ${successRate}%
+- Avg Turnout: ${Math.round(analytics.averageVoterTurnout)}%
+- Health Score: ${healthScore}/100
+    `.trim();
+  }
+};
 
 // src/utils/feature-flags.ts
 var feature_flags_exports = {};
@@ -1405,6 +1176,69 @@ __export(client_encryption_exports, {
   generateLocalPrivacyProof: () => generateLocalPrivacyProof,
   verifyLocalPrivacyProof: () => verifyLocalPrivacyProof
 });
+var MAX_DECRYPTABLE_VALUE = 4294967295n;
+var G = ed25519.ExtendedPoint.BASE;
+var hash = (data) => sha256(data);
+function generateElGamalKeypair(seed) {
+  const secretKey = seed ? hash(seed).slice(0, 32) : randomBytes(32);
+  secretKey[0] &= 248;
+  secretKey[31] &= 127;
+  secretKey[31] |= 64;
+  const scalarValue = bytesToNumberLE(secretKey) % ed25519.CURVE.n;
+  const publicKey = G.multiply(scalarValue).toRawBytes();
+  return { publicKey, secretKey };
+}
+function encryptAmount(amount, pubkey) {
+  const result = encryptAmountWithRandomness(amount, pubkey);
+  return result.ciphertext;
+}
+function encryptAmountWithRandomness(amount, pubkey, providedRandomness) {
+  if (amount < 0n) {
+    throw new Error("Amount must be non-negative");
+  }
+  if (amount > MAX_DECRYPTABLE_VALUE) {
+    throw new Error(`Amount exceeds maximum decryptable value (${MAX_DECRYPTABLE_VALUE})`);
+  }
+  const randomness = randomBytes(32);
+  randomness[0] &= 248;
+  randomness[31] &= 127;
+  randomness[31] |= 64;
+  const r = bytesToNumberLE(randomness) % ed25519.CURVE.n;
+  const pubkeyPoint = ed25519.ExtendedPoint.fromHex(bytesToHex(pubkey));
+  const amountPoint = amount === 0n ? ed25519.ExtendedPoint.ZERO : G.multiply(amount);
+  const maskedAmount = amountPoint.add(pubkeyPoint.multiply(r));
+  const commitment = maskedAmount.toRawBytes();
+  const handle = G.multiply(r).toRawBytes();
+  return {
+    ciphertext: {
+      commitment: { commitment },
+      handle: { handle }
+    },
+    randomness
+  };
+}
+function decryptAmount(ciphertext, secretKey, maxValue = 65536n) {
+  const C = ed25519.ExtendedPoint.fromHex(bytesToHex(ciphertext.commitment.commitment));
+  const D = ed25519.ExtendedPoint.fromHex(bytesToHex(ciphertext.handle.handle));
+  const sk = bytesToNumberLE(secretKey) % ed25519.CURVE.n;
+  const decryptedPoint = C.subtract(D.multiply(sk));
+  for (let i = 0n; i <= maxValue; i++) {
+    const testPoint = i === 0n ? ed25519.ExtendedPoint.ZERO : G.multiply(i);
+    if (testPoint.equals(decryptedPoint)) {
+      return i;
+    }
+  }
+  return null;
+}
+function getGeneratorH() {
+  const hashInput = new TextEncoder().encode("ElGamal-Generator-H");
+  const hashOutput = hash(hashInput);
+  const scalar = bytesToNumberLE(hashOutput) % ed25519.CURVE.n;
+  return G.multiply(scalar);
+}
+getGeneratorH();
+
+// src/utils/client-encryption.ts
 var ClientEncryptionService = class {
   keypair;
   featureFlags = getFeatureFlags();
@@ -1567,6 +1401,6 @@ async function verifyLocalPrivacyProof(proof, publicInputs, encrypted) {
   return bytesToHex(proofCommitment) === bytesToHex(encrypted.commitment) && bytesToHex(inputCommitment) === bytesToHex(encrypted.commitment);
 }
 
-export { ClientEncryptionService, FeatureFlagManager, TokenAccountState, TokenExtension, TokenProgram, account_diagnostics_exports, basisPointsToPercentage, calculateCompoundInterest, calculateInterest, calculateRequiredAmountForNetTransfer, calculateTransferFee, canTransfer, client_encryption_exports, createDiscriminatorErrorMessage, createMigrationPlan, createMigrationReport, createTransferHookInstruction, deriveAssociatedTokenAddress, deriveSplTokenAssociatedTokenAddress, deriveToken2022AssociatedTokenAddress, deserializeTokenMetadata, detectTokenProgram, diagnoseAccountFromChain, diagnoseBatchFromChain, estimateAccumulatedFees, estimateComputeUnits, exportDiagnosticReport, extractLegacyData, feature_flags_exports, formatBasisPoints, formatTokenAmount, generateConfidentialTransferProof, generateLocalPrivacyProof, getAllAssociatedTokenAddresses, getAssociatedTokenAccount, getConfidentialTransferConfig, getFeatureFlags, getInterestBearingConfig, getMigrationInstructions, getRequiredExtensions, getTokenProgramAddress, getTokenProgramFromAddress, getTokenProgramType, getTransferFeeConfig, hasConfidentialTransferExtension, hasInterestBearingExtension, hasTransferFeeExtension, inspectAccountData, isFeatureEnabled, isToken2022Mint, parseTokenAmount, percentageToBasisPoints, runAccountDiagnostics, runBatchDiagnostics, safeDecodeAgent, serializeTokenMetadata, simulateMigration, token_2022_extensions_exports, validateAccountDiscriminator, validateAssociatedTokenAddress, validateTransferHookInstruction, verifyConfidentialTransferProof, verifyLocalPrivacyProof };
-//# sourceMappingURL=chunk-F3DZMBUA.js.map
-//# sourceMappingURL=chunk-F3DZMBUA.js.map
+export { ClientEncryptionService, FeatureFlagManager, TokenExtension, TokenProgram, account_diagnostics_exports, client_encryption_exports, createDiscriminatorErrorMessage, createMigrationPlan, createMigrationReport, deriveAssociatedTokenAddress, deriveMultisigPda, deriveProposalPda, deriveSplTokenAssociatedTokenAddress, deriveToken2022AssociatedTokenAddress, detectTokenProgram, diagnoseAccountFromChain, diagnoseBatchFromChain, exportDiagnosticReport, extractLegacyData, feature_flags_exports, formatTokenAmount, generateLocalPrivacyProof, getAllAssociatedTokenAddresses, getAssociatedTokenAccount, getConfidentialTransferConfig, getFeatureFlags, getInterestBearingConfig, getMigrationInstructions, getTokenProgramAddress, getTokenProgramFromAddress, getTokenProgramType, getTransferFeeConfig, governance_helpers_exports, hasConfidentialTransferExtension, hasInterestBearingExtension, hasTransferFeeExtension, inspectAccountData, isFeatureEnabled, isToken2022Mint, parseTokenAmount, runAccountDiagnostics, runBatchDiagnostics, safeDecodeAgent, simulateMigration, validateAccountDiscriminator, validateAssociatedTokenAddress, verifyLocalPrivacyProof };
+//# sourceMappingURL=chunk-5QBSC4T4.js.map
+//# sourceMappingURL=chunk-5QBSC4T4.js.map