Client Reference

const client = new CredDAOClient(options: CredDAOClientOptions);

interface CredDAOClientOptions {
  provider: AnchorProvider;      // Anchor provider with wallet
  programId: PublicKey;          // CredDAO program ID
  oracleProgramId?: PublicKey;   // FairScore oracle program ID
  skipPreflight?: boolean;       // Skip preflight checks
}

program: Program

provider: AnchorProvider

connection: Connection

async getDaoConfig(): Promise<DaoConfig>

const config = await client.getDaoConfig();
console.log('Quorum:', config.quorumPercentage + '%');
console.log('Voting Period:', config.votingPeriod + ' seconds');

async getMemberProfile(wallet: PublicKey): Promise<MemberProfile>

const profile = await client.getMemberProfile(wallet.publicKey);
console.log('Tier:', profile.tier);
console.log('FairScore:', profile.fairscore.toNumber());
console.log('Active Days:', profile.activeDays.toNumber());

async registerMember(params: RegisterMemberParams): Promise<TransactionResult>

interface RegisterMemberParams {
  fairscore: number;
}

const result = await client.registerMember({ fairscore: 50 });
console.log('Registered:', result.signature);

calculateVotingPower(
  tokenBalance: number,
  fairscore: number
): VotingPowerResult

interface VotingPowerResult {
  quadraticBase: number;
  reputationMultiplier: number;
  totalPower: number;
}

const power = client.calculateVotingPower(10000, 78);
console.log('Voting Power:', power.totalPower);

async getProposal(proposalAddress: PublicKey): Promise<ProposalAccount>

async getActiveProposals(): Promise<ProposalAccount[]>

const proposals = await client.getActiveProposals();
proposals.forEach(p => {
  console.log(p.title, '-', p.state);
});

async createProposal(params: CreateProposalParams): Promise<TransactionResult>

interface CreateProposalParams {
  proposalType: ProposalType;
  title: string;
  description: string;
}

const result = await client.createProposal({
  proposalType: ProposalType.Standard,
  title: 'Treasury Allocation',
  description: 'Allocate funds for development...',
});

async castVote(params: CastVoteParams): Promise<TransactionResult>

interface CastVoteParams {
  proposalAddress: PublicKey;
  vote: VoteType;
}

await client.castVote({
  proposalAddress: proposal.publicKey,
  vote: VoteType.For,
});

async delegate(params: DelegateParams): Promise<TransactionResult>

interface DelegateParams {
  delegate: PublicKey;
}

await client.delegate({
  delegate: new PublicKey('7xKXtg2C...'),
});

async revokeDelegation(): Promise<TransactionResult>

async getDelegationRecord(wallet: PublicKey): Promise<DelegationRecord>

async getVoteRecords(wallet: PublicKey): Promise<VoteRecordAccount[]>

async getTopDelegates(options?: {
  sortBy?: 'efficiency' | 'delegators' | 'votingPower';
  limit?: number;
}): Promise<DelegateInfo[]>

interface TransactionResult {
  signature: string;
  proposalAddress?: PublicKey;
  votingPower?: number;
  efficiency?: number;
}