@ottochain/sdk 1.0.2 → 1.1.0

package/dist/apps/markets/types.js

@@ -1,252 +0,0 @@
-"use strict";
-/**
- * Markets Application Types
- *
- * Constants, types, and utilities for the Markets application on OttoChain.
- *
- * Note: When proto files are generated, enums will move to generated types.
- *
- * @packageDocumentation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMarketType = exports.isMarketState = exports.calculateGroupBuyDiscount = exports.calculateCrowdfundProgress = exports.validateCommitment = exports.calculateRefund = exports.calculatePayout = exports.calculateFees = exports.calculateNetCommitment = exports.isTerminalMarketState = exports.MARKET_TRANSITIONS = exports.MARKET_TYPE_CONFIGS = exports.DEFAULT_MARKET_CONFIG = exports.CommitmentSide = exports.MarketType = exports.MarketState = void 0;
-// ---------------------------------------------------------------------------
-// Enums (will be replaced by proto-generated versions)
-// ---------------------------------------------------------------------------
-/**
- * Market lifecycle states
- */
-var MarketState;
-(function (MarketState) {
-    MarketState[MarketState["UNSPECIFIED"] = 0] = "UNSPECIFIED";
-    /** Market is open for commitments */
-    MarketState[MarketState["OPEN"] = 1] = "OPEN";
-    /** Commitment period has ended, awaiting resolution */
-    MarketState[MarketState["CLOSED"] = 2] = "CLOSED";
-    /** Oracle has resolved the outcome */
-    MarketState[MarketState["RESOLVED"] = 3] = "RESOLVED";
-    /** Payouts distributed to winners */
-    MarketState[MarketState["SETTLED"] = 4] = "SETTLED";
-    /** Market cancelled, refunds issued */
-    MarketState[MarketState["CANCELLED"] = 5] = "CANCELLED";
-    /** Market is disputed */
-    MarketState[MarketState["DISPUTED"] = 6] = "DISPUTED";
-})(MarketState || (exports.MarketState = MarketState = {}));
-/**
- * Types of markets supported
- */
-var MarketType;
-(function (MarketType) {
-    MarketType[MarketType["UNSPECIFIED"] = 0] = "UNSPECIFIED";
-    /** Binary or multi-outcome prediction market */
-    MarketType[MarketType["PREDICTION"] = 1] = "PREDICTION";
-    /** Ascending/descending price auction */
-    MarketType[MarketType["AUCTION"] = 2] = "AUCTION";
-    /** All-or-nothing crowdfunding */
-    MarketType[MarketType["CROWDFUND"] = 3] = "CROWDFUND";
-    /** Group buying with volume discounts */
-    MarketType[MarketType["GROUP_BUY"] = 4] = "GROUP_BUY";
-})(MarketType || (exports.MarketType = MarketType = {}));
-/**
- * Commitment direction (for prediction markets)
- */
-var CommitmentSide;
-(function (CommitmentSide) {
-    CommitmentSide[CommitmentSide["UNSPECIFIED"] = 0] = "UNSPECIFIED";
-    CommitmentSide[CommitmentSide["YES"] = 1] = "YES";
-    CommitmentSide[CommitmentSide["NO"] = 2] = "NO";
-})(CommitmentSide || (exports.CommitmentSide = CommitmentSide = {}));
-/**
- * Default market configuration
- */
-exports.DEFAULT_MARKET_CONFIG = {
-    platformFeePercent: 0.01,
-    creatorFeePercent: 0.02,
-    oracleFeePercent: 0.01,
-    minQuorum: 100n,
-    resolutionWindowEpochs: 24,
-    disputeWindowEpochs: 12,
-    minCommitment: 1n,
-    maxSlippagePercent: 0.05,
-};
-/**
- * Type-specific market configurations
- */
-exports.MARKET_TYPE_CONFIGS = {
-    [MarketType.UNSPECIFIED]: {},
-    [MarketType.PREDICTION]: {
-        platformFeePercent: 0.02,
-        oracleFeePercent: 0.02,
-    },
-    [MarketType.AUCTION]: {
-        platformFeePercent: 0.025,
-        creatorFeePercent: 0,
-        oracleFeePercent: 0,
-        minQuorum: 1n,
-    },
-    [MarketType.CROWDFUND]: {
-        platformFeePercent: 0.03,
-        creatorFeePercent: 0,
-        oracleFeePercent: 0,
-        disputeWindowEpochs: 0,
-    },
-    [MarketType.GROUP_BUY]: {
-        platformFeePercent: 0.015,
-        creatorFeePercent: 0.01,
-        oracleFeePercent: 0,
-    },
-};
-// ---------------------------------------------------------------------------
-// State Machine Transitions
-// ---------------------------------------------------------------------------
-/**
- * Valid transitions for each market state
- */
-exports.MARKET_TRANSITIONS = {
-    [MarketState.UNSPECIFIED]: [],
-    [MarketState.OPEN]: ['close', 'cancel'],
-    [MarketState.CLOSED]: ['resolve', 'dispute', 'cancel'],
-    [MarketState.RESOLVED]: ['settle', 'dispute'],
-    [MarketState.SETTLED]: [], // Terminal state
-    [MarketState.CANCELLED]: [], // Terminal state
-    [MarketState.DISPUTED]: ['resolve_dispute', 'cancel'],
-};
-/**
- * Check if a market state is terminal
- */
-function isTerminalMarketState(state) {
-    return [
-        MarketState.SETTLED,
-        MarketState.CANCELLED,
-    ].includes(state);
-}
-exports.isTerminalMarketState = isTerminalMarketState;
-// ---------------------------------------------------------------------------
-// Commitment Calculations
-// ---------------------------------------------------------------------------
-/**
- * Calculate effective commitment after fees
- *
- * @param amount - Raw commitment amount
- * @param config - Market configuration (uses defaults if not provided)
- * @returns Net commitment amount after platform fees
- */
-function calculateNetCommitment(amount, config = {}) {
-    const feePercent = config.platformFeePercent ?? exports.DEFAULT_MARKET_CONFIG.platformFeePercent;
-    const feeAmount = (amount * BigInt(Math.floor(feePercent * 10000))) / 10000n;
-    return amount - feeAmount;
-}
-exports.calculateNetCommitment = calculateNetCommitment;
-/**
- * Calculate total fees for a commitment
- *
- * @param amount - Commitment amount
- * @param marketType - Type of market for type-specific fees
- * @returns Fee breakdown object
- */
-function calculateFees(amount, marketType = MarketType.PREDICTION) {
-    const typeConfig = { ...exports.DEFAULT_MARKET_CONFIG, ...exports.MARKET_TYPE_CONFIGS[marketType] };
-    const platform = (amount * BigInt(Math.floor(typeConfig.platformFeePercent * 10000))) / 10000n;
-    const creator = (amount * BigInt(Math.floor(typeConfig.creatorFeePercent * 10000))) / 10000n;
-    const oracle = (amount * BigInt(Math.floor(typeConfig.oracleFeePercent * 10000))) / 10000n;
-    return {
-        platform,
-        creator,
-        oracle,
-        total: platform + creator + oracle,
-    };
-}
-exports.calculateFees = calculateFees;
-/**
- * Calculate payout for a winning commitment in a prediction market
- *
- * Winner receives: their original + proportional share of losing pool (minus fees)
- *
- * @param shares - Pool and commitment details
- * @param marketType - Type of market for fee calculation
- * @returns Payout amount
- */
-function calculatePayout(shares, marketType = MarketType.PREDICTION) {
-    if (shares.winningPool === 0n)
-        return 0n;
-    const fees = calculateFees(shares.losingPool, marketType);
-    const distributablePool = shares.losingPool - fees.total;
-    // Proportional share of losing pool
-    const winnings = (distributablePool * shares.userCommitment) / shares.winningPool;
-    // Return original commitment + winnings
-    return shares.userCommitment + winnings;
-}
-exports.calculatePayout = calculatePayout;
-/**
- * Calculate refund for cancelled market
- *
- * @param commitment - Original commitment amount
- * @param refundFeePercent - Optional fee retained on refund (default 0)
- * @returns Refund amount
- */
-function calculateRefund(commitment, refundFeePercent = 0) {
-    const fee = (commitment * BigInt(Math.floor(refundFeePercent * 10000))) / 10000n;
-    return commitment - fee;
-}
-exports.calculateRefund = calculateRefund;
-/**
- * Validate a commitment against market rules
- */
-function validateCommitment(amount, marketState, config = {}) {
-    const minCommitment = config.minCommitment ?? exports.DEFAULT_MARKET_CONFIG.minCommitment;
-    if (marketState !== MarketState.OPEN) {
-        return { valid: false, reason: 'Market is not open for commitments' };
-    }
-    if (amount < minCommitment) {
-        return { valid: false, reason: `Commitment below minimum: ${minCommitment}` };
-    }
-    return { valid: true };
-}
-exports.validateCommitment = validateCommitment;
-/**
- * Calculate crowdfund campaign progress
- */
-function calculateCrowdfundProgress(current, goal) {
-    if (goal === 0n) {
-        return { current, goal, percentComplete: 0, goalReached: false };
-    }
-    const percentComplete = Number((current * 10000n) / goal) / 100;
-    return {
-        current,
-        goal,
-        percentComplete: Math.min(percentComplete, 100),
-        goalReached: current >= goal,
-    };
-}
-exports.calculateCrowdfundProgress = calculateCrowdfundProgress;
-/**
- * Calculate applicable discount based on participant count
- */
-function calculateGroupBuyDiscount(participantCount, tiers) {
-    // Sort tiers descending by minParticipants
-    const sortedTiers = [...tiers].sort((a, b) => b.minParticipants - a.minParticipants);
-    for (const tier of sortedTiers) {
-        if (participantCount >= tier.minParticipants) {
-            return tier.discountPercent;
-        }
-    }
-    return 0;
-}
-exports.calculateGroupBuyDiscount = calculateGroupBuyDiscount;
-// ---------------------------------------------------------------------------
-// Type Guards
-// ---------------------------------------------------------------------------
-/**
- * Check if a value is a valid MarketState
- */
-function isMarketState(value) {
-    return typeof value === 'number' && value in MarketState;
-}
-exports.isMarketState = isMarketState;
-/**
- * Check if a value is a valid MarketType
- */
-function isMarketType(value) {
-    return typeof value === 'number' && value in MarketType;
-}
-exports.isMarketType = isMarketType;

package/dist/apps/oracles/index.d.ts

@@ -1,26 +0,0 @@
-/**
- * Oracles Application
- *
- * Types and utilities for the Oracle system on OttoChain.
- * Oracles provide truth resolution for markets, disputes, and attestations.
- *
- * @example
- * ```typescript
- * import {
- *   OracleState,
- *   SlashingReason,
- *   calculateReputation,
- *   calculateSlashAmount,
- *   DEFAULT_ORACLE_CONFIG
- * } from '@ottochain/sdk/apps/oracles';
- *
- * // Calculate new reputation after successful resolution
- * const newRep = calculateReputation(50, REPUTATION_DELTAS.successfulResolution);
- *
- * // Calculate slash for timeout
- * const slashAmount = calculateSlashAmount(10000n, SlashingReason.TIMEOUT);
- * ```
- *
- * @packageDocumentation
- */
-export * from './types.js';

package/dist/apps/oracles/index.js

@@ -1,46 +0,0 @@
-"use strict";
-/**
- * Oracles Application
- *
- * Types and utilities for the Oracle system on OttoChain.
- * Oracles provide truth resolution for markets, disputes, and attestations.
- *
- * @example
- * ```typescript
- * import {
- *   OracleState,
- *   SlashingReason,
- *   calculateReputation,
- *   calculateSlashAmount,
- *   DEFAULT_ORACLE_CONFIG
- * } from '@ottochain/sdk/apps/oracles';
- *
- * // Calculate new reputation after successful resolution
- * const newRep = calculateReputation(50, REPUTATION_DELTAS.successfulResolution);
- *
- * // Calculate slash for timeout
- * const slashAmount = calculateSlashAmount(10000n, SlashingReason.TIMEOUT);
- * ```
- *
- * @packageDocumentation
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-// Note: Once proto files are generated, uncomment these exports:
-// export * from '../../generated/ottochain/apps/oracles/v1/oracle_pb.js';
-// export * from '../../generated/ottochain/apps/oracles/v1/resolution_pb.js';
-// Export convenience types, constants, and helpers
-__exportStar(require("./types.js"), exports);

package/dist/apps/oracles/types.d.ts

@@ -1,211 +0,0 @@
-/**
- * Oracles Application Types
- *
- * Constants, types, and utilities for the Oracle system on OttoChain.
- * Oracles provide truth resolution for markets and disputes.
- *
- * Note: When proto files are generated, enums will move to generated types.
- *
- * @packageDocumentation
- */
-/**
- * Oracle lifecycle states
- */
-export declare enum OracleState {
-    UNSPECIFIED = 0,
-    /** Oracle has registered but not yet staked */
-    REGISTERED = 1,
-    /** Oracle is staked and available for assignments */
-    ACTIVE = 2,
-    /** Oracle is currently assigned to resolve a market */
-    ASSIGNED = 3,
-    /** Oracle has submitted a resolution, in challenge period */
-    SUBMITTED = 4,
-    /** Oracle is under review due to dispute */
-    CHALLENGED = 5,
-    /** Oracle is suspended due to slashing */
-    SUSPENDED = 6,
-    /** Oracle has withdrawn stake and exited */
-    WITHDRAWN = 7
-}
-/**
- * Types of oracle resolutions
- */
-export declare enum ResolutionType {
-    UNSPECIFIED = 0,
-    /** Binary yes/no outcome */
-    BINARY = 1,
-    /** One of multiple predefined outcomes */
-    MULTI_CHOICE = 2,
-    /** Numeric value (e.g., price) */
-    NUMERIC = 3,
-    /** Free-form attestation */
-    ATTESTATION = 4
-}
-/**
- * Reasons for slashing oracle stake
- */
-export declare enum SlashingReason {
-    UNSPECIFIED = 0,
-    /** Failed to submit resolution in time */
-    TIMEOUT = 1,
-    /** Resolution overturned by dispute */
-    INCORRECT_RESOLUTION = 2,
-    /** Evidence of collusion or manipulation */
-    COLLUSION = 3,
-    /** Violation of oracle protocol */
-    PROTOCOL_VIOLATION = 4
-}
-/**
- * Oracle configuration type
- */
-export interface OracleConfig {
-    /** Minimum stake required to become an oracle (in base units) */
-    minStake: bigint;
-    /** Stake slashed for timeout (percentage) */
-    timeoutSlashPercent: number;
-    /** Stake slashed for incorrect resolution (percentage) */
-    incorrectSlashPercent: number;
-    /** Stake slashed for collusion (percentage) */
-    collusionSlashPercent: number;
-    /** Stake slashed for protocol violation (percentage) */
-    violationSlashPercent: number;
-    /** Epochs to wait before withdrawal after unstaking */
-    cooldownEpochs: number;
-    /** Base reputation for new oracles */
-    baseReputation: number;
-    /** Minimum reputation to accept high-value markets */
-    highValueThreshold: number;
-    /** Resolution window in epochs */
-    resolutionWindowEpochs: number;
-    /** Challenge window after submission in epochs */
-    challengeWindowEpochs: number;
-    /** Reward percentage from resolved market fees */
-    oracleRewardPercent: number;
-}
-/**
- * Default oracle configuration
- */
-export declare const DEFAULT_ORACLE_CONFIG: OracleConfig;
-/**
- * Slashing percentages by reason
- */
-export declare const SLASHING_PERCENTAGES: Record<SlashingReason, number>;
-/**
- * Valid transitions for each oracle state
- */
-export declare const ORACLE_TRANSITIONS: Record<OracleState, readonly string[]>;
-/**
- * Check if an oracle state is terminal
- */
-export declare function isTerminalOracleState(state: OracleState): boolean;
-/**
- * Check if an oracle can accept new assignments
- */
-export declare function canAcceptAssignment(state: OracleState): boolean;
-/**
- * Reputation update factors
- */
-export declare const REPUTATION_DELTAS: {
-    /** Successfully resolved market without challenge */
-    readonly successfulResolution: 5;
-    /** Resolution upheld after challenge */
-    readonly upheldChallenge: 10;
-    /** Resolution overturned (negative) */
-    readonly overturnedResolution: -25;
-    /** Timeout on assigned market (negative) */
-    readonly timeout: -15;
-    /** Collusion detected (negative) */
-    readonly collusion: -100;
-    /** Protocol violation (negative) */
-    readonly violation: -20;
-    /** Bonus for high-value market resolution */
-    readonly highValueBonus: 3;
-};
-/**
- * Calculate new reputation after an event
- *
- * @param currentReputation - Current reputation score
- * @param delta - Reputation change (positive or negative)
- * @param minReputation - Minimum reputation floor (default 0)
- * @returns New reputation score
- */
-export declare function calculateReputation(currentReputation: number, delta: number, minReputation?: number): number;
-/**
- * Calculate weighted reputation considering history
- *
- * @param baseReputation - Current base reputation
- * @param successCount - Number of successful resolutions
- * @param failureCount - Number of failed/overturned resolutions
- * @returns Weighted reputation score
- */
-export declare function calculateWeightedReputation(baseReputation: number, successCount: number, failureCount: number): number;
-/**
- * Check if oracle qualifies for high-value markets
- */
-export declare function qualifiesForHighValue(reputation: number, stake: bigint, threshold?: number, minStakeMultiplier?: number): boolean;
-/**
- * Slashing condition definition
- */
-export interface SlashingCondition {
-    reason: SlashingReason;
-    slashPercent: number;
-    description: string;
-    appealable: boolean;
-    suspensionEpochs: number;
-}
-/**
- * Predefined slashing conditions
- */
-export declare const SLASHING_CONDITIONS: Record<SlashingReason, SlashingCondition>;
-/**
- * Calculate slash amount for a given stake and reason
- *
- * @param stake - Oracle's current stake
- * @param reason - Reason for slashing
- * @returns Amount to be slashed
- */
-export declare function calculateSlashAmount(stake: bigint, reason: SlashingReason): bigint;
-/**
- * Calculate remaining stake after slashing
- */
-export declare function calculateStakeAfterSlash(stake: bigint, reason: SlashingReason): bigint;
-/**
- * Oracle candidate for selection
- */
-export interface OracleCandidate {
-    address: string;
-    reputation: number;
-    stake: bigint;
-    activeAssignments: number;
-    successRate: number;
-}
-/**
- * Calculate oracle selection score
- * Higher score = more likely to be selected
- *
- * @param candidate - Oracle candidate details
- * @param marketValue - Value of market to resolve (affects weight for high-value markets)
- * @returns Selection score
- */
-export declare function calculateSelectionScore(candidate: OracleCandidate, marketValue?: bigint): number;
-/**
- * Calculate oracle reward for successful resolution
- *
- * @param marketFees - Total fees collected from market
- * @param rewardPercent - Oracle's reward percentage (default from config)
- * @returns Oracle reward amount
- */
-export declare function calculateOracleReward(marketFees: bigint, rewardPercent?: number): bigint;
-/**
- * Check if a value is a valid OracleState
- */
-export declare function isOracleState(value: unknown): value is OracleState;
-/**
- * Check if a value is a valid SlashingReason
- */
-export declare function isSlashingReason(value: unknown): value is SlashingReason;
-/**
- * Check if a value is a valid ResolutionType
- */
-export declare function isResolutionType(value: unknown): value is ResolutionType;