@ottochain/sdk 0.2.0

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

@@ -0,0 +1,26 @@
+/**
+ * Markets Application
+ *
+ * Types and utilities for the Markets system on OttoChain.
+ * Supports prediction markets, auctions, crowdfunding, and group buys.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   MarketState,
+ *   MarketType,
+ *   calculatePayout,
+ *   DEFAULT_MARKET_CONFIG
+ * } from '@ottochain/sdk/apps/markets';
+ *
+ * // Calculate payout for a winning prediction
+ * const payout = calculatePayout({
+ *   winningPool: 1000n,
+ *   losingPool: 500n,
+ *   userCommitment: 100n,
+ * });
+ * ```
+ *
+ * @packageDocumentation
+ */
+export * from './types.js';

package/dist/apps/markets/index.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Markets Application
+ *
+ * Types and utilities for the Markets system on OttoChain.
+ * Supports prediction markets, auctions, crowdfunding, and group buys.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   MarketState,
+ *   MarketType,
+ *   calculatePayout,
+ *   DEFAULT_MARKET_CONFIG
+ * } from '@ottochain/sdk/apps/markets';
+ *
+ * // Calculate payout for a winning prediction
+ * const payout = calculatePayout({
+ *   winningPool: 1000n,
+ *   losingPool: 500n,
+ *   userCommitment: 100n,
+ * });
+ * ```
+ *
+ * @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/markets/v1/market_pb.js';
+// export * from '../../generated/ottochain/apps/markets/v1/commitment_pb.js';
+// Export convenience types, constants, and helpers
+__exportStar(require("./types.js"), exports);

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

@@ -0,0 +1,185 @@
+/**
+ * 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
+ */
+/**
+ * Market lifecycle states
+ */
+export declare enum MarketState {
+    UNSPECIFIED = 0,
+    /** Market is open for commitments */
+    OPEN = 1,
+    /** Commitment period has ended, awaiting resolution */
+    CLOSED = 2,
+    /** Oracle has resolved the outcome */
+    RESOLVED = 3,
+    /** Payouts distributed to winners */
+    SETTLED = 4,
+    /** Market cancelled, refunds issued */
+    CANCELLED = 5,
+    /** Market is disputed */
+    DISPUTED = 6
+}
+/**
+ * Types of markets supported
+ */
+export declare enum MarketType {
+    UNSPECIFIED = 0,
+    /** Binary or multi-outcome prediction market */
+    PREDICTION = 1,
+    /** Ascending/descending price auction */
+    AUCTION = 2,
+    /** All-or-nothing crowdfunding */
+    CROWDFUND = 3,
+    /** Group buying with volume discounts */
+    GROUP_BUY = 4
+}
+/**
+ * Commitment direction (for prediction markets)
+ */
+export declare enum CommitmentSide {
+    UNSPECIFIED = 0,
+    YES = 1,
+    NO = 2
+}
+/**
+ * Market configuration type
+ */
+export interface MarketConfig {
+    /** Platform fee as percentage (0.01 = 1%) */
+    platformFeePercent: number;
+    /** Market creator fee as percentage */
+    creatorFeePercent: number;
+    /** Oracle fee as percentage */
+    oracleFeePercent: number;
+    /** Minimum quorum for market validity (in tokens) */
+    minQuorum: bigint;
+    /** Default resolution window in epochs */
+    resolutionWindowEpochs: number;
+    /** Dispute window after resolution in epochs */
+    disputeWindowEpochs: number;
+    /** Minimum commitment amount */
+    minCommitment: bigint;
+    /** Maximum slippage for AMM-style markets */
+    maxSlippagePercent: number;
+}
+/**
+ * Default market configuration
+ */
+export declare const DEFAULT_MARKET_CONFIG: MarketConfig;
+/**
+ * Type-specific market configurations
+ */
+export declare const MARKET_TYPE_CONFIGS: Record<MarketType, Partial<MarketConfig>>;
+/**
+ * Valid transitions for each market state
+ */
+export declare const MARKET_TRANSITIONS: Record<MarketState, readonly string[]>;
+/**
+ * Check if a market state is terminal
+ */
+export declare function isTerminalMarketState(state: MarketState): boolean;
+/**
+ * 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
+ */
+export declare function calculateNetCommitment(amount: bigint, config?: Partial<MarketConfig>): bigint;
+/**
+ * Calculate total fees for a commitment
+ *
+ * @param amount - Commitment amount
+ * @param marketType - Type of market for type-specific fees
+ * @returns Fee breakdown object
+ */
+export declare function calculateFees(amount: bigint, marketType?: MarketType): {
+    platform: bigint;
+    creator: bigint;
+    oracle: bigint;
+    total: bigint;
+};
+/**
+ * Outcome shares for payout calculation
+ */
+export interface OutcomeShares {
+    /** Total committed to winning outcome */
+    winningPool: bigint;
+    /** Total committed to losing outcome(s) */
+    losingPool: bigint;
+    /** Individual's commitment to winning outcome */
+    userCommitment: bigint;
+}
+/**
+ * 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
+ */
+export declare function calculatePayout(shares: OutcomeShares, marketType?: MarketType): bigint;
+/**
+ * Calculate refund for cancelled market
+ *
+ * @param commitment - Original commitment amount
+ * @param refundFeePercent - Optional fee retained on refund (default 0)
+ * @returns Refund amount
+ */
+export declare function calculateRefund(commitment: bigint, refundFeePercent?: number): bigint;
+/**
+ * Validate a commitment meets market requirements
+ */
+export interface CommitmentValidation {
+    valid: boolean;
+    reason?: string;
+}
+/**
+ * Validate a commitment against market rules
+ */
+export declare function validateCommitment(amount: bigint, marketState: MarketState, config?: Partial<MarketConfig>): CommitmentValidation;
+/**
+ * Calculate crowdfund progress
+ */
+export interface CrowdfundProgress {
+    /** Current total committed */
+    current: bigint;
+    /** Target goal */
+    goal: bigint;
+    /** Percentage complete (0-100) */
+    percentComplete: number;
+    /** Whether goal has been reached */
+    goalReached: boolean;
+}
+/**
+ * Calculate crowdfund campaign progress
+ */
+export declare function calculateCrowdfundProgress(current: bigint, goal: bigint): CrowdfundProgress;
+/**
+ * Tier definition for group buys
+ */
+export interface GroupBuyTier {
+    /** Minimum participants for this tier */
+    minParticipants: number;
+    /** Discount percentage for this tier */
+    discountPercent: number;
+}
+/**
+ * Calculate applicable discount based on participant count
+ */
+export declare function calculateGroupBuyDiscount(participantCount: number, tiers: GroupBuyTier[]): number;
+/**
+ * Check if a value is a valid MarketState
+ */
+export declare function isMarketState(value: unknown): value is MarketState;
+/**
+ * Check if a value is a valid MarketType
+ */
+export declare function isMarketType(value: unknown): value is MarketType;

package/dist/apps/markets/types.js

@@ -0,0 +1,252 @@
+"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

@@ -0,0 +1,26 @@
+/**
+ * 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

@@ -0,0 +1,46 @@
+"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);