DAO

The AkitaDaoSDK manages the Akita Infinity DAO — a governance voting layer built on top of Akita’s ARC-58 smart wallet. Because the DAO controls a full smart wallet rather than a simple multisig or treasury, it can execute any smart contract call, transfer any asset, modify any protocol parameter, install or remove plugins, and interact with any contract on Algorand. There is no admin key — the protocol is entirely self-governing through democratic voting.

Voting Power

Voting power requires locking equal portions of AKTA and BONES tokens via the Dual Stake plugin. Neither token alone grants voting power. Power decays as the unlock date approaches, ensuring governance influence reflects ongoing commitment rather than a one-time lock.

Locked stakers receive 40% of all protocol revenue, distributed daily by the Revenue Manager Plugin.

Concepts

Proposals

A proposal is a batch of actions that the DAO can execute if approved. Each proposal goes through a lifecycle:

1. Draft — created by a proposer, can be edited
2. Submitted — open for voting
3. Voting — token holders cast votes
4. Finalized — voting period ends, outcome determined
5. Executed — approved actions are applied on-chain

Proposal Actions

Each proposal contains one or more actions. Supported action types:

Action	Description
UpgradeApp	Upgrade a contract’s approval/clear programs
AddPlugin	Install a plugin on the DAO wallet
AddNamedPlugin	Install a named plugin on the DAO wallet
RemovePlugin	Remove a plugin by key
RemoveNamedPlugin	Remove a plugin by name
ExecutePlugin	Execute a plugin via the DAO wallet
RemoveExecutePlugin	Remove an execution key
AddAllowances	Add spending allowances to an escrow
RemoveAllowances	Remove spending allowances
NewEscrow	Create a new escrow on the DAO wallet
ToggleEscrowLock	Lock or unlock an escrow
UpdateFields	Update DAO configuration fields

Configurable Fields

The UpdateFields action can modify many DAO parameters:

• aal — Akita App List (registered contract IDs)
• sal — Social App List
• pal — Plugin App List
• oal — Other App List (VRF beacon, NFD registry, etc.)
• akita_assets — AKTA and BONES asset IDs
• revenue_splits — Revenue distribution configuration
• wallet_fees, social_fees, staking_fees, subscription_fees, nft_fees, swap_fees — Fee structures
• content_policy — Content moderation policy CID
• Proposal settings per action type (duration, participation, approval thresholds)

Initialization

import { AkitaDaoSDK } from '@akta/sdk/dao'

const dao = new AkitaDaoSDK({ algorand })

For write operations (creating/voting on proposals):

const dao = new AkitaDaoSDK({
  algorand,
  factoryParams: {
    defaultSender: myAddress,
    defaultSigner: mySigner,
  },
})

The DAO SDK automatically connects to the DAO’s ARC-58 wallet:

const wallet = await dao.getWallet()

Creating Proposals

import { ProposalActionEnum } from '@akta/sdk/dao'

const result = await dao.newProposal({
  cid: proposalContentCID,  // IPFS CID for proposal description
  actions: [
    {
      type: ProposalActionEnum.AddNamedPlugin,
      name: 'new-feature',
      client: featurePluginSDK,
      global: true,
      methods: [],
    },
    {
      type: ProposalActionEnum.UpdateFields,
      field: 'wallet_fees',
      value: { createFee: 1_000_000n },
    },
  ],
})

const proposalId = result.return // The new proposal ID

Adding a Plugin via Proposal

At minimum, specify the plugin client and who can call it:

{
  type: ProposalActionEnum.AddPlugin,
  client: pluginSDK,
  global: true,
}

For more control, add optional restrictions:

{
  type: ProposalActionEnum.AddPlugin,
  client: pluginSDK,
  caller: callerAddress,
  escrow: 'ops-escrow',
  methods: [
    { name: pluginSDK.methodName, cooldown: 0n }
  ],
  sourceLink: 'https://github.com/...',
}

Updating DAO Fees

{
  type: ProposalActionEnum.UpdateFields,
  field: 'nft_fees',
  value: {
    marketplaceSalePercentageMin: 100n,  // 1% (basis points)
    marketplaceSalePercentageMax: 500n,  // 5%
    auctionCreationFee: 1_000_000n,      // 1 ALGO
  },
}

Updating Registered Apps

{
  type: ProposalActionEnum.UpdateFields,
  field: 'aal',  // Akita App List
  value: {
    staking: newStakingAppId,
    // Other fields keep their current values
  },
}

Editing Proposals

await dao.editProposal({
  id: proposalId,
  cid: updatedCID,
  actions: [/* updated actions */],
})

If the new actions cost more than the original, an additional payment is required automatically.

Proposal Lifecycle

// Submit for voting
await dao.submitProposal({ proposalId })

// Vote (0 = against, 1 = for)
await dao.voteProposal({ proposalId, vote: 1 })

// Finalize after voting period
await dao.finalizeProposal({ proposalId })

// Execute approved proposal
await dao.executeProposal({ proposalId })

Reading State

// Get DAO global state
const state = await dao.getGlobalState()

// Get a specific proposal with decoded actions
const proposal = await dao.getProposal(117n)
// Returns: { status, cid, votes, creator, votingTs, created, feesPaid, actions }

// Calculate proposal cost before creating
const cost = await dao.proposalCost({
  actions: [/* your actions */],
})
// Returns: { total, ... }

// Calculate setup cost
const setupCost = await dao.setupCost()

Decoded Proposals

getProposal() returns fully decoded action data:

const proposal = await dao.getProposal(1n)

for (const action of proposal.actions) {
  switch (action.type) {
    case ProposalActionEnum.AddPlugin:
      console.log('Plugin:', action.plugin)
      console.log('Caller:', action.caller)
      break
    case ProposalActionEnum.UpdateFields:
      console.log('Field:', action.field)
      console.log('Value:', action.value)
      break
    // ... handle other action types
  }
}