$STK Distribution

contract StrikeToken is ERC20, Ownable {
    uint256 public constant MAX_SUPPLY = 1_000_000_000 * 1e18; // 1 billion tokens

    constructor(address initialOwner)
        ERC20("Strike Token", "STRIKE")
        Ownable(initialOwner) {
        _mint(initialOwner, MAX_SUPPLY);
    }
}

if tokens_earned_this_epoch >= 30_000_000:
    # Mark current epoch as completed
    current_epoch.status = 'completed'
    current_epoch.is_active = False

    # Activate next epoch
    next_epoch.is_active = True
    next_epoch.start_date = now()

tokens_earned = 30M × (notional / base_notional)
                    × (leverage / 1000)
                    × (days_open / 21)

class TokenCalculatorService:
    CALCULATION_INTERVAL = 10  # seconds
    BATCH_SIZE = 100           # positions per cycle

    async def calculate_tokens(position):
        # Calculate time since last update
        days_since_last = (now - position.last_calculated) / 86400

        # Calculate incremental tokens
        new_tokens = calculate_tokens_for_position(
            epoch=current_epoch,
            notional_position=position.notional,
            leverage=position.leverage,
            days_open=days_since_last
        )

        # Update accumulated total
        position.tokens_earned += new_tokens
        position.last_calculated = now

async def claim_tokens(wallet_address: str):
    # Use atomic stored procedure for race-condition safety
    result = await execute_db_query(
        supabase.rpc('claim_tokens_atomic', {
            'wallet_addr': wallet_address
        })
    )

    claimable_amount = result.data[0]['claimable_amount']

    if claimable_amount > 0:
        # Transfer tokens from controller to user
        tx_result = await transfer_strike_tokens(
            recipient=wallet_address,
            amount=claimable_amount
        )

        return {
            'success': True,
            'tokens_claimed': claimable_amount,
            'tx_hash': tx_result['tx_hash']
        }

CREATE TABLE token_rewards (
    id BIGSERIAL PRIMARY KEY,
    position_id BIGINT UNIQUE NOT NULL,
    wallet_address TEXT NOT NULL,
    symbol TEXT NOT NULL,
    notional_position NUMERIC NOT NULL,
    leverage INTEGER NOT NULL,

    -- Timestamps
    opened_at TIMESTAMPTZ NOT NULL,
    last_calculated_at TIMESTAMPTZ,
    settled_at TIMESTAMPTZ,

    -- Token amounts
    tokens_earned NUMERIC DEFAULT 0,      -- Accumulated while open
    tokens_settled NUMERIC DEFAULT 0,     -- Final amount after close
    tokens_claimed NUMERIC DEFAULT 0,     -- Amount claimed to wallet

    -- Claiming metadata
    claim_tx_hash TEXT,
    claimed_at TIMESTAMPTZ,

    -- Epoch tracking
    epoch_number INTEGER NOT NULL,

    CONSTRAINT fk_position FOREIGN KEY (position_id)
        REFERENCES positions(id) ON DELETE CASCADE
);

CREATE OR REPLACE FUNCTION claim_tokens_atomic(wallet_addr TEXT)
RETURNS TABLE(claimable_amount NUMERIC) AS $$
DECLARE
    total_claimable NUMERIC;
BEGIN
    -- Calculate claimable amount (settled but not claimed)
    SELECT COALESCE(SUM(tokens_settled - tokens_claimed), 0)
    INTO total_claimable
    FROM token_rewards
    WHERE wallet_address = wallet_addr
      AND tokens_settled > tokens_claimed
    FOR UPDATE;  -- Lock rows to prevent race conditions

    -- Mark tokens as claimed
    UPDATE token_rewards
    SET tokens_claimed = tokens_settled,
        claimed_at = NOW()
    WHERE wallet_address = wallet_addr
      AND tokens_settled > tokens_claimed;

    RETURN QUERY SELECT total_claimable;
END;
$$ LANGUAGE plpgsql;

from decimal import Decimal, ROUND_DOWN

def _decimal_to_token_units(amount: Decimal, decimals: int) -> int:
    """Convert Decimal to token units (18 decimals for STRIKE)."""
    scaling_factor = Decimal(10) ** decimals
    return int((amount * scaling_factor).to_integral_value(rounding=ROUND_DOWN))

await create_token_reward_record(
    position_id=position_id,
    wallet_address=wallet_address,
    symbol=symbol,
    notional_position=notional,
    leverage=leverage,
    opened_at=datetime.utcnow()
)

await finalize_token_rewards_for_position(
    position_id=position_id,
    close_time=datetime.utcnow()
)

GET /tokens/{wallet_address}

{
  "wallet_address": "0x123...",
  "total_earned": "125000.50",
  "total_settled": "100000.00",
  "total_claimed": "50000.00",
  "claimable": "50000.00",
  "earning": "25000.50",
  "positions": [
    {
      "position_id": 42,
      "symbol": "BTC-PERP",
      "tokens_earned": "25000.50",
      "status": "open"
    }
  ]
}

POST /tokens/claim
Authorization: Bearer <wallet_signature>

{
  "wallet_address": "0x123..."
}

{
  "success": true,
  "tokens_claimed": "50000.00",
  "tx_hash": "0xabc...",
  "gas_used": 65000
}