@ottochain/sdk 0.2.0

package/dist/esm/apps/markets/state-machines/market-universal.json

@@ -0,0 +1,354 @@
+{
+    "metadata": {
+        "name": "Market",
+        "description": "Universal market state machine: predictions, auctions, crowdfunding, group buys",
+        "version": "1.1.0"
+    },
+    "states": {
+        "PROPOSED": {
+            "id": { "value": "PROPOSED" },
+            "isFinal": false,
+            "metadata": null
+        },
+        "OPEN": {
+            "id": { "value": "OPEN" },
+            "isFinal": false,
+            "metadata": null
+        },
+        "CLOSED": {
+            "id": { "value": "CLOSED" },
+            "isFinal": false,
+            "metadata": null
+        },
+        "RESOLVING": {
+            "id": { "value": "RESOLVING" },
+            "isFinal": false,
+            "metadata": null
+        },
+        "SETTLED": {
+            "id": { "value": "SETTLED" },
+            "isFinal": true,
+            "metadata": null
+        },
+        "REFUNDED": {
+            "id": { "value": "REFUNDED" },
+            "isFinal": true,
+            "metadata": null
+        },
+        "CANCELLED": {
+            "id": { "value": "CANCELLED" },
+            "isFinal": true,
+            "metadata": null
+        }
+    },
+    "initialState": { "value": "PROPOSED" },
+    "transitions": [
+        {
+            "from": { "value": "PROPOSED" },
+            "to": { "value": "OPEN" },
+            "eventName": "open",
+            "guard": {
+                "===": [
+                    { "var": "event.agent" },
+                    { "var": "state.creator" }
+                ]
+            },
+            "effect": {
+                "merge": [
+                    { "var": "state" },
+                    {
+                        "status": "OPEN",
+                        "openedAt": { "var": "$timestamp" }
+                    }
+                ]
+            },
+            "dependencies": []
+        },
+        {
+            "from": { "value": "PROPOSED" },
+            "to": { "value": "CANCELLED" },
+            "eventName": "cancel",
+            "guard": {
+                "===": [
+                    { "var": "event.agent" },
+                    { "var": "state.creator" }
+                ]
+            },
+            "effect": {
+                "merge": [
+                    { "var": "state" },
+                    {
+                        "status": "CANCELLED",
+                        "cancelledAt": { "var": "$timestamp" },
+                        "reason": { "var": "event.reason" }
+                    }
+                ]
+            },
+            "dependencies": []
+        },
+        {
+            "from": { "value": "OPEN" },
+            "to": { "value": "OPEN" },
+            "eventName": "commit",
+            "guard": {
+                "and": [
+                    { ">": [{ "var": "event.amount" }, 0] },
+                    {
+                        "or": [
+                            { "!": [{ "var": "state.deadline" }] },
+                            { "<=": [{ "var": "$timestamp" }, { "var": "state.deadline" }] }
+                        ]
+                    }
+                ]
+            },
+            "effect": {
+                "merge": [
+                    { "var": "state" },
+                    {
+                        "commitments": {
+                            "cat": [
+                                { "var": "state.commitments" },
+                                [{
+                                        "agent": { "var": "event.agent" },
+                                        "amount": { "var": "event.amount" },
+                                        "data": { "var": "event.data" },
+                                        "committedAt": { "var": "$timestamp" }
+                                    }]
+                            ]
+                        },
+                        "totalCommitted": {
+                            "+": [
+                                { "var": "state.totalCommitted" },
+                                { "var": "event.amount" }
+                            ]
+                        }
+                    }
+                ]
+            },
+            "dependencies": []
+        },
+        {
+            "from": { "value": "OPEN" },
+            "to": { "value": "CLOSED" },
+            "eventName": "close",
+            "guard": {
+                "or": [
+                    { "===": [{ "var": "event.agent" }, { "var": "state.creator" }] },
+                    {
+                        "and": [
+                            { "var": "state.deadline" },
+                            { ">=": [{ "var": "$timestamp" }, { "var": "state.deadline" }] }
+                        ]
+                    }
+                ]
+            },
+            "effect": {
+                "merge": [
+                    { "var": "state" },
+                    {
+                        "status": "CLOSED",
+                        "closedAt": { "var": "$timestamp" }
+                    }
+                ]
+            },
+            "dependencies": []
+        },
+        {
+            "from": { "value": "CLOSED" },
+            "to": { "value": "RESOLVING" },
+            "eventName": "submit_resolution",
+            "guard": {
+                "or": [
+                    { "in": [{ "var": "event.agent" }, { "var": "state.oracles" }] },
+                    { "===": [{ "var": "event.agent" }, { "var": "state.creator" }] }
+                ]
+            },
+            "effect": {
+                "merge": [
+                    { "var": "state" },
+                    {
+                        "status": "RESOLVING",
+                        "resolutions": {
+                            "cat": [
+                                { "var": "state.resolutions" },
+                                [{
+                                        "oracle": { "var": "event.agent" },
+                                        "outcome": { "var": "event.outcome" },
+                                        "proof": { "var": "event.proof" },
+                                        "submittedAt": { "var": "$timestamp" }
+                                    }]
+                            ]
+                        }
+                    }
+                ]
+            },
+            "dependencies": []
+        },
+        {
+            "from": { "value": "RESOLVING" },
+            "to": { "value": "RESOLVING" },
+            "eventName": "submit_resolution",
+            "guard": {
+                "and": [
+                    { "in": [{ "var": "event.agent" }, { "var": "state.oracles" }] },
+                    {
+                        "!": [{
+                                "in": [
+                                    { "var": "event.agent" },
+                                    { "map": [{ "var": "state.resolutions" }, { "var": "oracle" }] }
+                                ]
+                            }]
+                    }
+                ]
+            },
+            "effect": {
+                "merge": [
+                    { "var": "state" },
+                    {
+                        "resolutions": {
+                            "cat": [
+                                { "var": "state.resolutions" },
+                                [{
+                                        "oracle": { "var": "event.agent" },
+                                        "outcome": { "var": "event.outcome" },
+                                        "proof": { "var": "event.proof" },
+                                        "submittedAt": { "var": "$timestamp" }
+                                    }]
+                            ]
+                        }
+                    }
+                ]
+            },
+            "dependencies": []
+        },
+        {
+            "from": { "value": "RESOLVING" },
+            "to": { "value": "SETTLED" },
+            "eventName": "finalize",
+            "guard": {
+                "or": [
+                    { ">=": [{ "size": { "var": "state.resolutions" } }, { "var": "state.quorum" }] },
+                    { "===": [{ "var": "state.marketType" }, "crowdfund"] },
+                    { "===": [{ "var": "state.marketType" }, "group_buy"] },
+                    { "===": [{ "var": "state.marketType" }, "auction"] }
+                ]
+            },
+            "effect": {
+                "merge": [
+                    { "var": "state" },
+                    {
+                        "status": "SETTLED",
+                        "settledAt": { "var": "$timestamp" },
+                        "finalOutcome": { "var": "event.outcome" },
+                        "settlement": { "var": "event.settlement" }
+                    }
+                ]
+            },
+            "dependencies": []
+        },
+        {
+            "from": { "value": "CLOSED" },
+            "to": { "value": "REFUNDED" },
+            "eventName": "refund",
+            "guard": {
+                "and": [
+                    { "var": "state.threshold" },
+                    { "<": [{ "var": "state.totalCommitted" }, { "var": "state.threshold" }] }
+                ]
+            },
+            "effect": {
+                "merge": [
+                    { "var": "state" },
+                    {
+                        "status": "REFUNDED",
+                        "refundedAt": { "var": "$timestamp" },
+                        "reason": "threshold_not_met"
+                    }
+                ]
+            },
+            "dependencies": []
+        },
+        {
+            "from": { "value": "RESOLVING" },
+            "to": { "value": "REFUNDED" },
+            "eventName": "refund",
+            "guard": {
+                "or": [
+                    { "===": [{ "var": "event.agent" }, { "var": "state.creator" }] },
+                    {
+                        ">=": [
+                            {
+                                "size": {
+                                    "filter": [
+                                        { "var": "state.resolutions" },
+                                        { "===": [{ "var": "outcome" }, "INVALID"] }
+                                    ]
+                                }
+                            },
+                            { "var": "state.quorum" }
+                        ]
+                    }
+                ]
+            },
+            "effect": {
+                "merge": [
+                    { "var": "state" },
+                    {
+                        "status": "REFUNDED",
+                        "refundedAt": { "var": "$timestamp" },
+                        "reason": { "var": "event.reason" }
+                    }
+                ]
+            },
+            "dependencies": []
+        },
+        {
+            "from": { "value": "SETTLED" },
+            "to": { "value": "SETTLED" },
+            "eventName": "claim",
+            "guard": {
+                "and": [
+                    {
+                        ">": [
+                            {
+                                "size": {
+                                    "filter": [
+                                        { "var": "state.commitments" },
+                                        { "===": [{ "var": "agent" }, { "var": "event.agent" }] }
+                                    ]
+                                }
+                            },
+                            0
+                        ]
+                    },
+                    {
+                        "!": [{
+                                "in": [
+                                    { "var": "event.agent" },
+                                    { "map": [{ "var": "state.claims" }, { "var": "agent" }] }
+                                ]
+                            }]
+                    }
+                ]
+            },
+            "effect": {
+                "merge": [
+                    { "var": "state" },
+                    {
+                        "claims": {
+                            "cat": [
+                                { "var": "state.claims" },
+                                [{
+                                        "agent": { "var": "event.agent" },
+                                        "amount": { "var": "event.amount" },
+                                        "claimedAt": { "var": "$timestamp" }
+                                    }]
+                            ]
+                        }
+                    }
+                ]
+            },
+            "dependencies": []
+        }
+    ]
+}

package/dist/esm/apps/markets/types.js

@@ -0,0 +1,206 @@
+/**
+ * Markets Application Types
+ *
+ * Constants, types, and utilities for the Markets application on OttoChain.
+ *
+ * Core types (MarketType, MarketState, Market, Commitment, Resolution) are
+ * exported from proto-generated types in index.ts.
+ *
+ * @packageDocumentation
+ */
+import { MarketType, MarketState } from '../../generated/ottochain/apps/markets/v1/market_pb.js';
+/**
+ * Commitment direction (for prediction markets)
+ */
+export var CommitmentSide;
+(function (CommitmentSide) {
+    CommitmentSide[CommitmentSide["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    CommitmentSide[CommitmentSide["YES"] = 1] = "YES";
+    CommitmentSide[CommitmentSide["NO"] = 2] = "NO";
+})(CommitmentSide || (CommitmentSide = {}));
+/**
+ * Default market configuration
+ */
+export const 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
+ */
+export const 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 (aligned with proto MarketState enum)
+ */
+export const MARKET_TRANSITIONS = {
+    [MarketState.UNSPECIFIED]: [],
+    [MarketState.PROPOSED]: ['open', 'cancel'],
+    [MarketState.OPEN]: ['close', 'cancel', 'commit'],
+    [MarketState.CLOSED]: ['submit_resolution', 'refund'],
+    [MarketState.RESOLVING]: ['submit_resolution', 'finalize', 'refund'],
+    [MarketState.SETTLED]: ['claim'], // Terminal (only claims allowed)
+    [MarketState.REFUNDED]: [], // Terminal state
+    [MarketState.CANCELLED]: [], // Terminal state
+};
+/**
+ * Check if a market state is terminal
+ */
+export function isTerminalMarketState(state) {
+    return [
+        MarketState.SETTLED,
+        MarketState.REFUNDED,
+        MarketState.CANCELLED,
+    ].includes(state);
+}
+// ---------------------------------------------------------------------------
+// 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
+ */
+export function calculateNetCommitment(amount, config = {}) {
+    const feePercent = config.platformFeePercent ?? DEFAULT_MARKET_CONFIG.platformFeePercent;
+    const feeAmount = (amount * BigInt(Math.floor(feePercent * 10000))) / 10000n;
+    return amount - feeAmount;
+}
+/**
+ * Calculate total fees for a commitment
+ *
+ * @param amount - Commitment amount
+ * @param marketType - Type of market for type-specific fees
+ * @returns Fee breakdown object
+ */
+export function calculateFees(amount, marketType = MarketType.PREDICTION) {
+    const typeConfig = { ...DEFAULT_MARKET_CONFIG, ...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,
+    };
+}
+/**
+ * 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 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;
+}
+/**
+ * Calculate refund for cancelled market
+ *
+ * @param commitment - Original commitment amount
+ * @param refundFeePercent - Optional fee retained on refund (default 0)
+ * @returns Refund amount
+ */
+export function calculateRefund(commitment, refundFeePercent = 0) {
+    const fee = (commitment * BigInt(Math.floor(refundFeePercent * 10000))) / 10000n;
+    return commitment - fee;
+}
+/**
+ * Validate a commitment against market rules
+ */
+export function validateCommitment(amount, marketState, config = {}) {
+    const minCommitment = config.minCommitment ?? 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 };
+}
+/**
+ * Calculate crowdfund campaign progress
+ */
+export 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,
+    };
+}
+/**
+ * Calculate applicable discount based on participant count
+ */
+export 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;
+}
+// ---------------------------------------------------------------------------
+// Type Guards
+// ---------------------------------------------------------------------------
+/**
+ * Check if a value is a valid MarketState
+ */
+export function isMarketState(value) {
+    return typeof value === 'number' && value in MarketState;
+}
+/**
+ * Check if a value is a valid MarketType
+ */
+export function isMarketType(value) {
+    return typeof value === 'number' && value in MarketType;
+}

package/dist/esm/apps/oracles/index.js

@@ -0,0 +1,42 @@
+/**
+ * Oracles Application
+ *
+ * Types and utilities for oracles on OttoChain.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   OracleState,
+ *   Oracle,
+ *   getOracleDefinition,
+ *   DEFAULT_ORACLE_CONFIG
+ * } from '@ottochain/sdk/apps/oracles';
+ *
+ * const oracleDef = getOracleDefinition();
+ * ```
+ *
+ * @packageDocumentation
+ */
+// Re-export generated protobuf types (source of truth)
+export { OracleState, OracleReputation, SlashingEvent, Oracle, RegisterOracleRequest, ActivateOracleRequest, AddStakeRequest, WithdrawStakeRequest, SlashOracleRequest, WithdrawOracleRequest, OracleDefinition, oracleStateFromJSON, oracleStateToJSON, } from '../../generated/ottochain/apps/oracles/v1/oracle.js';
+// ---------------------------------------------------------------------------
+// State Machine JSON Definitions
+// ---------------------------------------------------------------------------
+import oracleDef from './state-machines/oracle.json';
+export const ORACLE_DEFINITIONS = {
+    Oracle: oracleDef,
+};
+/**
+ * Get the oracle state machine definition.
+ */
+export function getOracleDefinition(type = 'Oracle') {
+    return ORACLE_DEFINITIONS[type];
+}
+/**
+ * Default oracle configuration.
+ */
+export const DEFAULT_ORACLE_CONFIG = {
+    minStake: 100,
+    baseReputation: 10,
+    reputationDecay: 0.95,
+};