// OTCM Token Parameters (TypeScript)

// Supply parameters

// Token standard

// Authority configuration

// On-chain metadata

// 1:1 Backing Structure Implementation

// Backing parameters

// Custody verification

// Redemption capability

// Backing verification formula
// backingRatio = custodiedShares / circulatingTokens
// Must equal 1.0000 (100%) at all times

// OTCM Token Mint Configuration (Rust)
// OTCM Token Mint Configuration

/// Total supply (fixed at genesis)

/// Decimal precision

/// Token standard extensions

/// Authority configuration

pub fn is_supply_fixed(&self) -> bool {

// Graduation Mechanism Implementation

// Graduation trigger

// Migration process

// Step 1: Pause bonding curve trading

// Step 2: Calculate LP allocation

// Step 3: Create CPMM pool

// Step 4: Lock LP tokens permanently

// Post-graduation state

//
Version: Vesting6.0 Schedule| ImplementationImplementation: (TypeScript)Rust/Anchor 

/// VestingOn-chain configurationvesting 

config:— one per ST22 issuer allocation #[account] pub struct VestingAccount {

totalAllocation:pub number;version: u8, /// The wallet that receives tokens as they unlock pub beneficiary: Pubkey, /// The ST22 mint this vesting schedule applies to pub mint: Pubkey, /// Total tokens allocated to this vesting schedule pub total_allocation: u64, /// Tokens claimed so far pub total_claimed: u64, /// Unix timestamp of graduation event — set by BondingCurve program on graduation /// Zero until graduation occurs pub graduation_timestamp: i64, /// Bitmask of which phases have been claimed (bit 0 = phase 1, etc.) pub claimed_phases: u8, /// Bump seed for PDA derivation pub bump: u8, } /// Five vesting phases — enforced by Transfer Hook Control 24 #[derive(BorshSerialize, BorshDeserialize, Clone, Copy, PartialEq)] pub enum VestingPhase { Phase1MintCompletion = 0, // 60%20% of— totalimmediate supply

vestingPeriods:mint 5;Phase2Graduation = 1, // Number20% of— unlockat events

releasePercentage:market 20;cap Phase3SixMonths = 2, // %20% — 6 months post-graduation Phase4TwelveMonths = 3, // 20% — 12 months post-graduation Phase5EighteenMonths = 4, // 20% — 18 months post-graduation } impl VestingAccount { pub const PHASE_ALLOCATION_BPS: u64 = 2000; // 20% per period

};

points)
    pub const MONTHS_6_SECONDS:  i64 = 15_778_800; // Vesting6 periodsmonths 

periods:seconds [

const MONTHS_12_SECONDS: i64 = 31_557_600; // 12 months in seconds pub const MONTHS_18_SECONDS: i64 = 47_336_400; // 18 months in seconds /// Returns the unlockable amount for a given phase at the current time pub fn unlockable_for_phase( &self, phase: VestingPhase, current_timestamp: i64, ) -> Result {

id:// 1,

trigger:claimed 'MINT_COMPLETION',

percentage:return 20,

unlockCondition:let 'IMMEDIATE',

status:= 'UNLOCKED'1u8 |<< 'LOCKED',

as u8); if self.claimed_phases & phase_bit != 0 { return Ok(0); },

let phase_allocation = self.total_allocation .checked_mul(Self::PHASE_ALLOCATION_BPS) .ok_or(VestingError::Overflow)? .checked_div(10_000) .ok_or(VestingError::Overflow)?; let is_unlocked = match phase {

id:VestingPhase::Phase1MintCompletion 2,

trigger:true, 'GRADUATION',

percentage:Immediate 20,

unlockCondition:=> 'MARKET_CAP{ self.graduation_timestamp > 0 // Graduation has occurred } VestingPhase::Phase3SixMonths => { self.graduation_timestamp > 0 && current_timestamp >= $250,000',

status: 'UNLOCKED' | 'LOCKED',

},

{

id: 3,

trigger: 'TIME_BASED',

percentage: 20,

unlockCondition: 'self.graduation_timestamp +.checked_add(Self::MONTHS_6_SECONDS) 6_MONTHS',

status:} 'UNLOCKED'VestingPhase::Phase4TwelveMonths |=> 'LOCKED',

},

{

id: 4,

trigger: 'TIME_BASED',

percentage: 20,

unlockCondition: 'self.graduation_timestamp +> 12_MONTHS',

status:&& 'UNLOCKED'current_timestamp |>= 'LOCKED',

},

{

id: 5,

trigger: 'TIME_BASED',

percentage: 20,

unlockCondition: 'self.graduation_timestamp +.checked_add(Self::MONTHS_12_SECONDS) 18_MONTHS',

status:} 'UNLOCKED'VestingPhase::Phase5EighteenMonths |=> 'LOCKED',

self.graduation_timestamp > 0 && current_timestamp >= self.graduation_timestamp .checked_add(Self::MONTHS_18_SECONDS) .ok_or(VestingError::Overflow)? },

]};

if is_unlocked { Ok(phase_allocation) } else { Ok(0) }
    }

    /// VestingTotal accountcurrently 

vestingAccount:across all phases pub fn total_claimable(&self, current_timestamp: i64) -> Result {

owner:let Pubkey;phases = [ VestingPhase::Phase1MintCompletion, VestingPhase::Phase2Graduation, VestingPhase::Phase3SixMonths, VestingPhase::Phase4TwelveMonths, VestingPhase::Phase5EighteenMonths, ]; phases.iter().try_fold(0u64, |acc, &phase| { let unlockable = self.unlockable_for_phase(phase, current_timestamp)?; acc.checked_add(unlockable).ok_or(error!(VestingError::Overflow)) }) } } /// Transfer Hook Control 24 — enforces vesting locks /// Called by Hook layer before every ST22 transfer pub fn check_vesting_lock( vesting_account: &VestingAccount, transfer_amount: u64, sender_wallet: &Pubkey, current_timestamp: i64, ) -> Result<()> { // IssuerOnly applies to the beneficiary wallet

escrowAccount:if Pubkey;&vesting_account.beneficiary != sender_wallet { return Ok(()); } // PDACalculate holdinghow many tokens are currently locked let total_unlocked = vesting_account .total_claimable(current_timestamp)? .checked_add(vesting_account.total_claimed) .ok_or(VestingError::Overflow)?; let locked_amount = vesting_account.total_allocation .saturating_sub(total_unlocked); // Reject if transfer would require locked tokens

Vesting Schedule Summary

totalLocked:24-Hour number;

totalClaimed:Control number;

nextUnlockTimestamp:(velocity number;

};

}a minimum 24-hour gap between vesting claims for the same wallet — preventing rapid sequential claim-and-sell patterns.

🔹 12.2.5 Anti-Dump Mechanisms

Beyond vesting, additional anti-dump mechanisms protect token holders:

• Daily Sell Limit: Maximum 1% of daily volume can be sold by any single wallet
• Price Impact Circuit Breaker: Transactions exceeding 2% price impact are rejected
• Velocity Detection: Rapid sequential sells from related wallets trigger freeze
• Cool-Down Period: 24-hour minimum between vesting claims

🔹 12.2.6 Vesting Visualization

// Vesting Timeline Visualization
// Visual representation of vesting schedule

Month 0 (Mint) ████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 20%

Month 0+ (Grad) ████████████████████████████████████████░░░░░░░░░░ 40%

Month 6 ████████████████████████████████████████████████░░ 60%

Month 12 ████████████████████████████████████████████████░░ 80%

Month 18 ██████████████████████████████████████████████████ 100%

█ = Unlocked tokens ░ = Locked tokens

Key Events:

├─--- Day 0: Token minting → 20% immediately available
├─--- Graduation: $250K MC reached → Additional 20% unlocked
├─--- +6 months: Time-based release → Additional 20% unlocked
├─--- +12 months: Time-based release → Additional 20% unlocked
└─--- +18 months: Final release → All tokens fully vested

💸 12.3 Revenue Model: Perpetual 5% Transaction Fee

🔹 12.3.1 Fee Structure Overview

The OTCM Protocol generates sustainable revenue through a 5% transaction fee applied to all trades executed on CEDEX. This fee structure provides predictable, volume-based revenue while remaining competitive with traditional securities trading costs.

🔹 12.3.2 Fee Distribution Mechanism

// Fee Distribution Mechanism

interface FeeDistribution {

/**

• 5% transaction fee distribution mechanism

• Executed automatically on each CEDEX trade

*/

// Fee calculation

calculation: {

totalFeeRate: 500; // 5.00% in basis points

appliedTo: 'TRADE_VALUE'; // USD equivalent

collectOn: ['BUY', 'SELL']; // Both directions

};

// Distribution split

distribution: {

otcmProtocol: {

percentage: 80; // 4% of trade (80% of fee)

recipient: OTCM_TREASURY_ADDRESS;

usage: [

'PROTOCOL_DEVELOPMENT',

'OPERATIONAL_COSTS',

'LIQUIDITY_PROVISION',

'TREASURY_GROWTH',

];

};

smtIssuer: {

percentage: 20; // 1% of trade (20% of fee)

recipient: ISSUER_REVENUE_ADDRESS;

usage: [

'ISSUER_REVENUE',

'STAKING_REWARDS_FUNDING',

'OPERATIONAL_SUPPORT',

];

};

};

// Fee collection

collection: {

timing: 'ATOMIC_WITH_TRADE'; // Same transaction

currency: 'TRADE_CURRENCY'; // USDC/SOL/etc

settlement: 'IMMEDIATE';

};

}

🔹 12.3.3 Revenue Projections by Volume

Revenue scales linearly with trading volume. The following table illustrates revenue at various volume levels:

Annual Protocol Revenue = Daily Volume × 4% × 365

🔹 12.3.4 Fee Collection Implementation

// Fee Collection Smart Contract (Rust/Anchor)
// Fee collection executed atomically with each trade
pub fn collect_transaction_fee(

ctx: Context<CollectFee>,

trade_amount: u64,

) -> Result<()> {

// Calculate total fee (5%)
let total_fee = trade_amount

.checked_mul(FEE_RATE_BPS as u64) // 500 bps

.ok_or(ErrorCode::Overflow)?

.checked_div(10_000)

.ok_or(ErrorCode::Overflow)?;

// Calculate splits
let protocol_share = total_fee

.checked_mul(80) // 80% of fee = 4% of trade

.ok_or(ErrorCode::Overflow)?

.checked_div(100)

.ok_or(ErrorCode::Overflow)?;

let issuer_share = total_fee

.checked_sub(protocol_share)

.ok_or(ErrorCode::Overflow)?; // 20% of fee = 1% of trade

// Transfer to protocol treasury

transfer_to_treasury(

&ctx.accounts.trade_account,

&ctx.accounts.protocol_treasury,

protocol_share,

)?;

// Transfer to issuer

transfer_to_issuer(

&ctx.accounts.trade_account,

&ctx.accounts.issuer_revenue,

issuer_share,

)?;

// Emit event for tracking
emit!(FeeCollected {

trade_amount,

total_fee,

protocol_share,

issuer_share,

timestamp: Clock::get()?.unix_timestamp,

});

Ok(())

}

🔹 12.3.5 Comparative Fee Analysis

OTCM's 5% transaction fee compares favorably with traditional securities trading costs when considering the full service bundle:

💡 Value Proposition

OTCM's 5% fee includes comprehensive compliance infrastructure (KYC/AML, accreditation), SEC-registered transfer agent custody, shareholder registry, immutable audit trail, and 24/7 trading. Traditional alternatives require separate fees for each service.

🔹 12.3.6 Five-Year Revenue Projections

🏗️ 12.4 Staking Rewards Architecture

🔹 12.4.1 Staking Model Overview

OTCM Protocol implements a staking mechanism that enables token holders to earn passive income through participation in the protocol's security and governance. Individual ST22 staking nodes provide continuous rewards with industry-leading compounding frequency.

"Staking transforms passive token holding into active protocol participation, aligning holder incentives with long-term network success while providing sustainable passive income."

🔹 12.4.2 APY Configuration & Ranges

🔹 12.4.3 Epoch Duration & Compounding

OTCM staking utilizes short epochs for maximized compounding benefit:

🔹 12.4.4 Compounding Mathematics

The effective APY differs from nominal APY due to compounding frequency. The following formula calculates effective annual yield:

APY_effective = (1 + APY_nominal / n)^n - 1

Where n = number of compounding periods per year (~140 for OTCM staking).

🔹 12.4.5 Staking Pool Implementation

// Staking Pool Configuration

interface StakingPool {

/**

• ST22 staking pool configuration

• Each SMT issuer maintains separate staking pool

*/

// Pool identification

poolId: Pubkey;

issuerId: string;

tokenMint: Pubkey;

// APY configuration

apyConfig: {

currentApy: number; // Basis points (1500 = 15%)

minApy: 800; // 8% minimum

maxApy: 6000; // 60% maximum

adjustmentFrequency: 'EPOCH'; // Can adjust each epoch

};

// Epoch configuration

epochConfig: {

durationSlots: 5616; // ~2.6 days at 400ms/slot

currentEpoch: number;

epochStartSlot: number;

nextDistribution: Date;

};

// Pool state

poolState: {

totalStaked: number;

totalStakers: number;

rewardsAvailable: number;

rewardsDistributed: number;

lastDistributionEpoch: number;

};

// Rewards funding

rewardsFunding: {

source: 'ISSUER_REVENUE'; // 1% transaction fee share

autoReplenish: true;

reserveTarget: number; // 3 epochs worth of rewards

};

}

🔹 12.4.6 LP Reinvestment Mechanism

A portion of staking rewards automatically flows back to the OTCM Liquidity Pool, strengthening protocol reserves:

🔹 12.4.7 Staking Rewards Distribution

// Staking Rewards Distribution (Rust/Anchor)
// Staking rewards distribution per epoch
pub fn distribute_staking_rewards(

ctx: Context<DistributeRewards>,

epoch: u64,

) -> Result<()> {

let pool = &mut ctx.accounts.staking_pool;
// Verify epoch has ended
require!(

Clock::get()?.slot >= pool.epoch_config.epoch_start_slot + pool.epoch_config.duration_slots,

ErrorCode::EpochNotComplete

);

// Calculate rewards for this epoch
let epoch_rate = pool.apy_config.current_apy

.checked_div(140) // ~140 epochs per year

.ok_or(ErrorCode::Overflow)?;

let total_rewards = pool.pool_state.total_staked

.checked_mul(epoch_rate as u64)

.ok_or(ErrorCode::Overflow)?

.checked_div(10_000) // Convert from basis points

.ok_or(ErrorCode::Overflow)?;

// Calculate LP reinvestment (2%)
let lp_reinvestment = total_rewards

.checked_mul(2)

.ok_or(ErrorCode::Overflow)?

.checked_div(100)

.ok_or(ErrorCode::Overflow)?;

let staker_rewards = total_rewards

.checked_sub(lp_reinvestment)

.ok_or(ErrorCode::Overflow)?;

// Transfer LP reinvestment

transfer_to_master_lp(

&ctx.accounts.rewards_vault,

&ctx.accounts.master_lp,

lp_reinvestment,

)?;

// Distribute to stakers (proportional to stake)

distribute_to_stakers(&ctx, staker_rewards)?;

// Update pool state

pool.pool_state.rewards_distributed += total_rewards;

pool.pool_state.last_distribution_epoch = epoch;

// Advance to next epoch

pool.epoch_config.current_epoch += 1;

pool.epoch_config.epoch_start_slot = Clock::get()?.slot;

emit!(RewardsDistributed {

epoch,

total_rewards,

lp_reinvestment,

staker_rewards,

stakers_count: pool.pool_state.total_stakers,

});

Ok(())

}

🏦 12.5 SOL Treasury Strategy

🔹 12.5.1 Strategic Rationale

OTCM Protocol allocates a significant portion of offering proceeds to building a SOL treasury, positioning the company among the first publicly traded entities to maintain significant blockchain asset reserves. This strategy provides multiple strategic benefits:

• Network Alignment: Direct exposure to Solana ecosystem growth
• Operational Funding: Staking yields fund ongoing operations
• Balance Sheet Innovation: Pioneering corporate blockchain treasury management
• Protocol Participation: Active participation in Solana governance and validation
• Hedge Against Fiat Debasement: Digital asset reserves as inflation hedge

🔹 12.5.2 Treasury Allocation

🔹 12.5.3 Staking Yield Projections

The SOL treasury generates passive income through native Solana staking:

Treasury Target: 6-8% annual staking yields, generating $480,000-$640,000 in operational funding annually.

🔹 12.5.4 Treasury Management Policy

// Treasury Management Policy

interface TreasuryManagementPolicy {

/**

• SOL Treasury management framework

*/

// Allocation strategy

allocation: {

stakingAllocation: 90; // 90% actively staked

liquidReserve: 10; // 10% liquid for operations

};

// Staking configuration

staking: {

validatorSelection: 'DIVERSIFIED'; // Multiple validators

minimumValidators: 5;

maxPerValidator: 25; // 25% max per validator

validatorCriteria: [

'TOP_100_BY_STAKE',

'COMMISSION_UNDER_10_PERCENT',

'UPTIME_ABOVE_99_PERCENT',

'NO_SLASHING_HISTORY',

];

};

// Yield management

yieldManagement: {

compoundingFrequency: 'EPOCH'; // Each Solana epoch

yieldDistribution: {

operations: 60; // 60% to operations

treasuryGrowth: 30; // 30% compounded to treasury

stakingReserve: 10; // 10% to staking rewards reserve

};

};

// Risk management

riskManagement: {

maxDrawdown: 20; // 20% max allowed drawdown

rebalanceThreshold: 30; // Rebalance if allocation drifts 30%

liquidityMinimum: 500_000; // $500K minimum liquid

};

}

🔹 12.5.5 Risk Management Framework

The SOL treasury incorporates comprehensive risk management:

• Validator Diversification: Maximum 25% stake with any single validator
• Slashing Protection: Only stake with validators having no slashing history
• Liquidity Reserve: 10% maintained liquid for operational needs
• Rebalancing: Automatic rebalancing when allocations drift beyond thresholds
• Price Volatility: Accept SOL price volatility as strategic exposure to ecosystem growth ⚠️ Price Volatility Risk

SOL treasury value will fluctuate with SOL market price. While this creates potential upside from price appreciation, it also exposes the treasury to downside risk. This volatility is accepted as strategic exposure to the Solana ecosystem.

💰 SOL TREASURY STAKING — RISK SPECIFICATION

Version: 6.0 | Applies To: $8,000,000 SOL Treasury Allocation

Validator Selection Criteria

The SOL treasury is delegated to native Solana staking validators (not liquid staking derivatives). This decision was made to eliminate smart contract risk associated with LST protocols (Marinade, Jito SOL, bSOL, etc.).

Staking Risk Matrix

Staking Mechanics and Epoch Timing

Solana Epoch Duration: ~2.6 days (432,000 slots)
Stake Activation: Takes 1 epoch to become active after delegation
Stake Deactivation: Takes 1 epoch to become withdrawable after deactivation

TREASURY LIQUIDITY SCHEDULE:
  Liquid reserve (10%):    $800,000 — immediately accessible
  Unstakeable in 1 epoch:  ~$1,600,000 (20% of staked)
  Unstakeable in 2 epochs: ~$3,200,000 (40% of staked)
  Full liquidity:          ~90 days (worst case: sequential undelegation)

OPERATIONAL IMPLICATION:
  Treasury cannot respond to a $7.2M emergency within 1 epoch.
  The $800,000 liquid reserve is the only immediately accessible capital.
  Protocol must maintain sufficient OTCM token operational reserve
  to cover 90 days of operating expenses independently of SOL treasury.

Validator Monitoring and Rebalancing

const TREASURY_MONITORING = {
  // Alert thresholds
  alerts: {
    validatorCommissionIncrease: { threshold: 0.02, action: 'REVIEW_REDELEGATE' },
    validatorUptimeDrop: { threshold: 0.99, window_days: 7, action: 'REVIEW_REDELEGATE' },
    epochRewardMissed: { consecutiveEpochs: 2, action: 'INVESTIGATE' },
    stakeConcentrationExceeded: { threshold: 0.25, action: 'REDELEGATE_IMMEDIATELY' },
  },

  // Rebalancing rules
  rebalancing: {
    trigger: 'allocation_drift_exceeds_30_percent',
    method: 'GRADUAL',         // Redelegate over 3 epochs to minimize unstaking cost
    governanceRequired: false,  // Treasury multisig (3-of-5) sufficient for rebalancing
    daoVoteRequired: false,
  },

  // Reporting
  reporting: {
    frequency: 'QUARTERLY',
    format: 'SEC_DISCLOSURE',  // Published as 8-K or 10-Q exhibit
    custodian: 'EMPIRE_STOCK_TRANSFER',
  },
};

📊 12.6 Economic Sustainability Analysis

🔹 12.6.1 Value Flow Architecture

The OTCM Protocol creates a self-sustaining economic ecosystem where value flows continuously between participants:

// Value Flow Architecture
// OTCM Protocol Value Flow Architecture
┌─────────────────────────────────────────────────────────────────────────---┐
│                     OTCM PROTOCOL VALUE FLOW                            │
└─────────────────────────────────────────────────────────────────────────---┘
┌─────────────────────---┐
│    SMT ISSUERS      │
│  (Issue ST22 Tokens)│
└──────────---┬──────────---┘
│
│ Minting Fee ($1K-$25K)
│ + 40% tokens to LP
▼
┌─────────────────────---┐
│    CEDEX TRADING    │◄────--- Investors Buy/Sell
│   (5% Transaction)  │
└──────────---┬──────────---┘
│
┌──────────────────---┼──────────────────---┐
│                  │                  │
│ 4%               │ 1%               │
▼                  ▼                  │
┌─────────────────---┐  ┌─────────────────---┐        │
│ OTCM PROTOCOL   │  │ SMT ISSUER      │        │
│   TREASURY      │  │   REVENUE       │        │
└────────---┬────────---┘  └────────---┬────────---┘        │
│                    │                 │
│                    │ Funds Staking   │
│                    ▼                 │
│           ┌─────────────────---┐        │
│           │ STAKING REWARDS │◄───────---┘
│           │  (8-60% APY)    │    2% LP Reinvestment
│           └────────---┬────────---┘
│                    │
▼                    ▼
┌─────────────────────────────────────────---┐
│          LIQUIDITY POOL GROWTH          │
│    (Permanent, Non-Withdrawable)        │
└─────────────────────────────────────────---┘

🔹 12.6.2 Token Velocity Management

Excessive token velocity can undermine value. OTCM manages velocity through multiple mechanisms:

🔹 12.6.3 Deflationary Mechanisms

While OTCM maintains fixed supply, effective circulating supply decreases over time through:

• LP Lock: 40% of supply permanently non-circulating in liquidity pools
• Staking Lock: Active staking removes tokens from circulation
• Lost Wallets: Standard blockchain attrition from lost private keys
• Graduation Burns: LP tokens burned at graduation, permanently locking liquidity

🔹 12.6.4 Long-Term Projections

✓ Economic Sustainability

The OTCM Protocol creates a self-sustaining economic loop: trading generates fees → fees fund operations and staking rewards → staking rewards attract more stakers → stakers reduce sell pressure → reduced sell pressure supports price → higher price attracts more issuers and traders → more trading generates more fees.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━