Subcommand Mapping in DAOCLI

Oct 13, 2025 by magicalceylontours.com 122 views

DAOCLI Technical Specification – Bonding Curve DAO Functionality (Detailed)

This section provides an in-depth technical description of the bonding curve DAO functionality on Solana, including fund flow, algorithm design, subcommand mapping, and sample code for both the CLI (in TypeScript using Commander.js) and the on-chain smart contract (in Rust using Anchor). This specification is intended for handoff to engineering teams.

Overview

The bonding curve DAO module is responsible for:

Token Issuance: Minting DAO tokens to users when they deposit SOL during the bonding curve sale phase.
Dynamic Price Calculation: Adjusting the token price according to a predefined mathematical bonding curve (e.g. exponential or tiered).
Fund Flow & Reserve Management: Dividing incoming SOL deposits between:
- A reserve pool (to enable redemptions and liquidity).
- The DAO treasury (for operational or investment purposes).
- A fee component taken by the platform (e.g. 1% fee on every trade).
Liquidity Migration: When a target (e.g. a preset market cap or time limit) is reached, automatically trigger migration of the remaining reserve into a third-party AMM (e.g. Raydium) to seed a liquidity pool. LP tokens may be burned to permanently lock liquidity.
Redemption Mechanism (Optional): Allow users to sell tokens back during the sale phase (if permitted) by burning DAO tokens and receiving SOL from the reserve.
State Management: Persist the following on-chain state:
- Total tokens sold (supply)
- Current token price
- Accumulated reserve balance
- Treasury balance
- Fund flow details (fees collected, split ratios)
- Target conditions for liquidity migration

Subcommand Mapping in DAOCLI

DAOCLI will expose subcommands to manage the lifecycle of a bonding curve DAO:

daocli init
- Purpose: Initialize a new DAO configuration, including bonding curve parameters.
- Actions:
  - Read configuration parameters from a JSON file (e.g., target fundraising amount, initial token price, bonding curve parameters, fee percentages, treasury split, etc.).
  - Prepare deployment metadata.
  - (Later) Invoke contract deployment (via the deploy subcommand).
daocli deploy
- Purpose: Deploy the bonding curve smart contract (and associated modules such as governance, treasury vesting) on Solana.
- Actions:
  - Call the Anchor CLI to compile and deploy the bonding curve contract.
  - Save the deployed contract address and version info.
daocli buy
- Purpose: Simulate or process a deposit into the bonding curve.
- Actions:
  - Accept parameters: deposit amount (in SOL) and user identifier.
  - Internally call the bonding curve contract’s deposit function.
  - Return a JSON summary showing:
    - Number of DAO tokens minted.
    - New total supply.
    - Updated token price.
    - Funds allocated to reserve vs. treasury.
daocli create-pool
- Purpose: When the fundraising target is reached, trigger the liquidity migration process.
- Actions:
  - Call the bonding curve contract to “close” the sale.
  - Invoke a third-party API (e.g. Raydium) to create a liquidity pool with the remaining reserve and unsold tokens.
  - Optionally, send a command to burn the resulting LP tokens to lock liquidity permanently.
daocli upgrade
- Purpose: Upgrade deployed DAO contracts to new versions, migrating state if necessary.

Detailed Bonding Curve Design and Fund Flow

1. Bonding Curve Mathematics

A bonding curve is a function f(s) that relates the token price to the total supply s (i.e. tokens sold so far). A common model is an exponential curve:

Price = initial_price × exp(k × s)

Initial Price (p0): The starting price per token (e.g., 0.0001 SOL).
Growth Constant (k): Determines the rate of price increase per token sold.
Total Supply (s): Sum of all DAO tokens sold.

When a user deposits an amount A (in SOL), the contract calculates how many tokens Δs can be minted such that the integral of the bonding curve from s to s + Δs equals A (minus fees). Mathematically:

∫(s to s+Δs) f(x) dx = A_effective

Where A_effective = A - fee(A). The contract then updates:

s_new = s + Δs
price_new = f(s_new)
reserve increases by A_effective (this fund backs redemptions)
A portion fee (e.g., 1% of A) is split to the treasury.

2. Fund Flow Details

User Deposit:
- User sends SOL to the bonding curve contract.
- The contract computes Δs based on the deposit and current supply.
- DAO tokens are minted and sent to the user.
- The deposit is split:
  - A fee portion (e.g., 1%) is sent immediately to the DAO treasury.
  - The remainder is added to the reserve pool for liquidity.
Liquidity Migration:
- When a trigger condition is met (e.g., target market cap or fundraising period ends), the contract is “closed.”
- The reserve funds and any unsold DAO tokens are used to seed a liquidity pool on Raydium via a third-party API.
- LP tokens from this pool are burned (sent to a burn address) to ensure the liquidity remains locked permanently.
Redemption (if enabled):
- Optionally, before liquidity migration, users may sell DAO tokens back to the contract.
- The contract calculates the refund value using the inverse bonding curve integral and returns SOL from the reserve.
- The sold tokens are burned.
Governance & Treasury:
- Post-sale, the DAO treasury (accumulated fees) is governed by token holders.
- Further spending or reallocation of treasury funds requires governance proposals and votes.

Sample Code

Below are sample code snippets for both the CLI integration (TypeScript) and a simplified bonding curve smart contract snippet in Rust (using Anchor).

A. TypeScript (Commander.js CLI – Sample for `buy` Command)

#!/usr/bin/env ts-node
import { Command } from 'commander';
import axios from 'axios';
import { execFile } from 'child_process';
import { promisify } from 'util';

const execFileAsync = promisify(execFile);
const program = new Command();

interface BuyResponse {
  mintedTokens: number;
  newSupply: number;
  newPrice: number;
  treasuryAllocation: number;
  reserveAllocation: number;
}

// Command: daocli buy <amount>
program
  .command('buy <amount>')
  .description('Deposit SOL to buy DAO tokens via the bonding curve')
  .option('--user <id>', 'User identifier')
  .option('--json', 'Output result in JSON')
  .action(async (amount: string, options) => {
    const depositAmount = parseFloat(amount);
    // Simulate calling the on-chain bonding curve contract.
    // In production, this will be an on-chain transaction via solana-web3.js.
    // Here, we mimic the calculation:
    const initialPrice = 0.0001; // Example initial price (SOL per token)
    const k = 0.00003606;        // Growth constant
    let currentSupply = 0;       // This would be retrieved from contract state
    // Simplified calculation: tokens minted = depositAmount / currentPrice (ignoring integration)
    const currentPrice = initialPrice * Math.exp(k * currentSupply);
    const feePercent = 0.01;     // 1% fee
    const fee = depositAmount * feePercent;
    const effectiveAmount = depositAmount - fee;
    // For simplicity, assume linear behavior for small deposits:
    const mintedTokens = effectiveAmount / currentPrice;
    currentSupply += mintedTokens;
    const newPrice = initialPrice * Math.exp(k * currentSupply);
    // Treasury receives the fee; reserve gets effective amount.
    const response: BuyResponse = {
      mintedTokens,
      newSupply: currentSupply,
      newPrice,
      treasuryAllocation: fee,
      reserveAllocation: effectiveAmount
    };
    
    if (options.json) {
      console.log(JSON.stringify(response));
    } else {
      console.log(`Minted ${mintedTokens.toFixed(2)} tokens.`);
      console.log(`New total supply: ${currentSupply.toFixed(2)} tokens.`);
      console.log(`New token price: ${newPrice.toExponential(4)} SOL per token.`);
      console.log(`Treasury fee: ${fee.toFixed(4)} SOL; Reserve: ${effectiveAmount.toFixed(4)} SOL.`);
    }
  });

program.parse(process.argv);

Explanation:
This sample buy command simulates a deposit into the bonding curve system. In a production version, the CLI would:

Retrieve the current supply and price from the on-chain state (via solana-web3.js).
Construct and send a transaction to the bonding curve contract.
Parse the transaction receipt to extract minted token quantity and updated state.
Output a structured JSON response if the --json flag is set.

B. Rust (Anchor Smart

Q&A: DAOCLI Technical Specification – Bonding Curve DAO Functionality

Q: What is the bonding curve DAO module responsible for?

A: The bonding curve DAO module is responsible for token issuance, dynamic price calculation, fund flow and reserve management, liquidity migration, redemption mechanism (optional), and state management.

Q: What is the purpose of the daocli init subcommand?

A: The daocli init subcommand is used to initialize a new DAO configuration, including bonding curve parameters.

Q: What is the purpose of the daocli deploy subcommand?

A: The daocli deploy subcommand is used to deploy the bonding curve smart contract (and associated modules such as governance, treasury vesting) on Solana.

Q: What is the purpose of the daocli buy subcommand?

A: The daocli buy subcommand is used to simulate or process a deposit into the bonding curve.

Q: What is the purpose of the daocli create-pool subcommand?

A: The daocli create-pool subcommand is used to trigger the liquidity migration process when the fundraising target is reached.

Q: What is the purpose of the daocli upgrade subcommand?

A: The daocli upgrade subcommand is used to upgrade deployed DAO contracts to new versions, migrating state if necessary.

Q: What is the bonding curve mathematics used in the DAOCLI specification?

A: The bonding curve mathematics used in the DAOCLI specification is an exponential curve, where the price is calculated as Price = initial_price × exp(k × s), where s is the total supply.

Q: How does the bonding curve contract calculate the number of tokens to mint?

A: The bonding curve contract calculates the number of tokens to mint using the deposit amount, current supply, and bonding curve formula.

Q: What is the purpose of the liquidity migration process?

A: The liquidity migration process is used to migrate the remaining reserve into a third-party AMM (e.g. Raydium) to seed a liquidity pool.

Q: What is the purpose of the redemption mechanism (optional)?

A: The redemption mechanism (optional) is used to allow users to sell tokens back to the contract before liquidity migration.

Q: How does the DAOCLI specification handle governance and treasury?

A: The DAOCLI specification handles governance and treasury by allowing token holders to govern the DAO treasury (accumulated fees) and requiring governance proposals and votes for further spending or reallocation of treasury funds.

Q: What is the purpose of the sample code provided in the DAOCLI specification?

A: The sample code provided in the DAOCLI specification is used to illustrate the implementation of the bonding curve DAO functionality in both TypeScript (for the CLI) and Rust (for the smart contract).

Q: What is the expected outcome of the daocli buy command?

A: The expected outcome of the daocli buy command is to mint DAO tokens, update the total supply, and return a JSON summary showing the number of tokens minted, new total supply, updated token price, and funds allocated to reserve vs. treasury.

Q: What is the expected outcome of the daocli create-pool command?

A: The expected outcome of the daocli create-pool command is to trigger the liquidity migration process, create a liquidity pool with the remaining reserve and unsold tokens, and burn LP tokens to lock liquidity permanently.

Q: What is the expected outcome of the daocli upgrade command?

A: The expected outcome of the daocli upgrade command is to upgrade deployed DAO contracts to new versions, migrating state if necessary.