@ottochain/sdk 1.7.0-beta.2 → 2.1.0

package/dist/esm/apps/markets/state-machines/market-prediction.js

@@ -0,0 +1,482 @@
+import { defineFiberApp } from "../../../schema/fiber-app.js";
+/**
+ * Binary or multi-outcome prediction market with oracle resolution and position staking.
+ */
+export const marketPredictionDef = defineFiberApp({
+    metadata: {
+        name: "MarketPrediction",
+        app: "markets",
+        type: "prediction",
+        version: "1.0.0",
+        description: "Binary or multi-outcome prediction market with oracle resolution and position staking",
+        crossReferences: {
+            oracleId: "Links to IdentityOracle that resolves the outcome",
+            creatorIdentityId: "Links to creator's IdentityAgent",
+        },
+    },
+    createSchema: {
+        required: ["creator", "outcomes", "oracles", "quorum"],
+        properties: {
+            creator: {
+                type: "address",
+                description: "DAG address of the market creator",
+                immutable: true,
+            },
+            outcomes: {
+                type: "array",
+                description: "Valid outcome identifiers",
+                immutable: true,
+            },
+            oracles: {
+                type: "array",
+                description: "Authorized oracle addresses",
+                immutable: true,
+            },
+            quorum: {
+                type: "number",
+                description: "Minimum oracle submissions needed to resolve",
+                immutable: true,
+            },
+            deadline: { type: "timestamp", description: "Optional trading deadline" },
+        },
+    },
+    stateSchema: {
+        properties: {
+            status: { type: "string", computed: true },
+            creator: { type: "address", immutable: true },
+            outcomes: { type: "array", immutable: true },
+            oracles: { type: "array", immutable: true },
+            quorum: { type: "number", immutable: true },
+            deadline: { type: "timestamp" },
+            positions: { type: "object", computed: true },
+            totalPool: { type: "number", computed: true },
+            resolutions: { type: "array", computed: true },
+            finalOutcome: { type: "string", computed: true },
+            claims: { type: "array", computed: true },
+        },
+    },
+    eventSchemas: {
+        open: { description: "Open the market for trading" },
+        cancel: {
+            description: "Cancel the market before opening",
+            properties: { reason: { type: "string" } },
+        },
+        take_position: {
+            description: "Take a position on an outcome",
+            required: ["outcome", "amount"],
+            properties: {
+                outcome: { type: "string" },
+                amount: { type: "number", minimum: 0 },
+            },
+        },
+        close: { description: "Close trading" },
+        submit_resolution: {
+            description: "Submit oracle resolution",
+            required: ["outcome", "proof"],
+            properties: {
+                outcome: { type: "string" },
+                proof: { type: "string" },
+            },
+        },
+        finalize: {
+            description: "Finalize market after quorum reached",
+            properties: { outcome: { type: "string" } },
+        },
+        dispute: {
+            description: "Dispute the resolution",
+            required: ["stake"],
+            properties: {
+                stake: { type: "number", minimum: 0 },
+                reason: { type: "string" },
+            },
+        },
+        ruling: {
+            description: "Judicial ruling on dispute",
+            properties: {
+                judicialRuling: { type: "boolean" },
+                outcome: { type: "string" },
+                rulingId: { type: "string" },
+            },
+        },
+        invalidate: { description: "Invalidate market by oracle consensus" },
+        claim: {
+            description: "Claim payout after settlement",
+            properties: { amount: { type: "number" } },
+        },
+    },
+    states: {
+        PROPOSED: {
+            id: "PROPOSED",
+            isFinal: false,
+            metadata: { description: "Market created but not yet open for trading" },
+        },
+        OPEN: {
+            id: "OPEN",
+            isFinal: false,
+            metadata: { description: "Accepting positions on outcomes" },
+        },
+        CLOSED: {
+            id: "CLOSED",
+            isFinal: false,
+            metadata: { description: "No more positions, awaiting resolution" },
+        },
+        RESOLVING: {
+            id: "RESOLVING",
+            isFinal: false,
+            metadata: { description: "Oracle(s) submitting resolution" },
+        },
+        DISPUTED: {
+            id: "DISPUTED",
+            isFinal: false,
+            metadata: { description: "Resolution challenged, awaiting arbitration" },
+        },
+        SETTLED: {
+            id: "SETTLED",
+            isFinal: true,
+            metadata: { description: "Outcome finalized, payouts available" },
+        },
+        REFUNDED: {
+            id: "REFUNDED",
+            isFinal: true,
+            metadata: { description: "Market invalidated, all positions refunded" },
+        },
+        CANCELLED: {
+            id: "CANCELLED",
+            isFinal: true,
+            metadata: { description: "Market cancelled before opening" },
+        },
+    },
+    initialState: "PROPOSED",
+    transitions: [
+        {
+            from: "PROPOSED",
+            to: "OPEN",
+            eventName: "open",
+            guard: { "===": [{ var: "event.agent" }, { var: "state.creator" }] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        status: "OPEN",
+                        openedAt: { var: "$timestamp" },
+                        positions: {},
+                        totalPool: 0,
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "PROPOSED",
+            to: "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: "OPEN",
+            to: "OPEN",
+            eventName: "take_position",
+            guard: {
+                and: [
+                    { ">": [{ var: "event.amount" }, 0] },
+                    { in: [{ var: "event.outcome" }, { var: "state.outcomes" }] },
+                    {
+                        or: [
+                            { "!": [{ var: "state.deadline" }] },
+                            { "<=": [{ var: "$timestamp" }, { var: "state.deadline" }] },
+                        ],
+                    },
+                ],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        positions: {
+                            merge: [
+                                { var: "state.positions" },
+                                {
+                                    __computed: {
+                                        cat: [
+                                            { var: "event.agent" },
+                                            "_",
+                                            { var: "event.outcome" },
+                                        ],
+                                    },
+                                },
+                            ],
+                        },
+                        totalPool: {
+                            "+": [{ var: "state.totalPool" }, { var: "event.amount" }],
+                        },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "OPEN",
+            to: "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: "CLOSED",
+            to: "RESOLVING",
+            eventName: "submit_resolution",
+            guard: { in: [{ var: "event.agent" }, { var: "state.oracles" }] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        status: "RESOLVING",
+                        resolutions: [
+                            {
+                                oracle: { var: "event.agent" },
+                                outcome: { var: "event.outcome" },
+                                proof: { var: "event.proof" },
+                                submittedAt: { var: "$timestamp" },
+                            },
+                        ],
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "RESOLVING",
+            to: "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: "RESOLVING",
+            to: "SETTLED",
+            eventName: "finalize",
+            guard: {
+                ">=": [{ size: { var: "state.resolutions" } }, { var: "state.quorum" }],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        status: "SETTLED",
+                        settledAt: { var: "$timestamp" },
+                        finalOutcome: { var: "event.outcome" },
+                        claims: [],
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "RESOLVING",
+            to: "DISPUTED",
+            eventName: "dispute",
+            guard: {
+                and: [
+                    {
+                        ">": [
+                            {
+                                size: {
+                                    filter: [
+                                        { var: "state.positions" },
+                                        { "===": [{ var: "agent" }, { var: "event.agent" }] },
+                                    ],
+                                },
+                            },
+                            0,
+                        ],
+                    },
+                    { var: "event.stake" },
+                ],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        status: "DISPUTED",
+                        disputedAt: { var: "$timestamp" },
+                        disputedBy: { var: "event.agent" },
+                        disputeStake: { var: "event.stake" },
+                        disputeReason: { var: "event.reason" },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "DISPUTED",
+            to: "SETTLED",
+            eventName: "ruling",
+            guard: { var: "event.judicialRuling" },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        status: "SETTLED",
+                        settledAt: { var: "$timestamp" },
+                        finalOutcome: { var: "event.outcome" },
+                        rulingId: { var: "event.rulingId" },
+                        claims: [],
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "RESOLVING",
+            to: "REFUNDED",
+            eventName: "invalidate",
+            guard: {
+                ">=": [
+                    {
+                        size: {
+                            filter: [
+                                { var: "state.resolutions" },
+                                { "===": [{ var: "outcome" }, "INVALID"] },
+                            ],
+                        },
+                    },
+                    { var: "state.quorum" },
+                ],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        status: "REFUNDED",
+                        refundedAt: { var: "$timestamp" },
+                        reason: "oracle_invalidation",
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "SETTLED",
+            to: "SETTLED",
+            eventName: "claim",
+            guard: {
+                and: [
+                    {
+                        ">": [
+                            {
+                                size: {
+                                    filter: [
+                                        { var: "state.positions" },
+                                        {
+                                            and: [
+                                                { "===": [{ var: "agent" }, { var: "event.agent" }] },
+                                                {
+                                                    "===": [
+                                                        { var: "outcome" },
+                                                        { var: "state.finalOutcome" },
+                                                    ],
+                                                },
+                                            ],
+                                        },
+                                    ],
+                                },
+                            },
+                            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/state-machines/market-universal.js

@@ -0,0 +1,126 @@
+import { defineFiberApp } from "../../../schema/fiber-app.js";
+/**
+ * Minimal market state machine - extend for custom use cases.
+ */
+export const marketUniversalDef = defineFiberApp({
+    metadata: {
+        name: "MarketUniversal",
+        app: "markets",
+        type: "universal",
+        version: "1.0.0",
+        description: "Minimal market state machine - extend for custom use cases",
+    },
+    createSchema: {
+        properties: {},
+    },
+    stateSchema: {
+        properties: {
+            status: { type: "string" },
+            totalCommitted: { type: "number", computed: true },
+        },
+    },
+    eventSchemas: {
+        open: { description: "Open the market for participation" },
+        cancel: { description: "Cancel the market" },
+        commit: {
+            description: "Commit funds to the market",
+            properties: {
+                amount: { type: "number", minimum: 0 },
+            },
+        },
+        close: { description: "Close the market to new commits" },
+        settle: { description: "Settle the market" },
+    },
+    states: {
+        PROPOSED: { id: "PROPOSED", isFinal: false, metadata: null },
+        OPEN: { id: "OPEN", isFinal: false, metadata: null },
+        CLOSED: { id: "CLOSED", isFinal: false, metadata: null },
+        SETTLED: { id: "SETTLED", isFinal: true, metadata: null },
+        CANCELLED: { id: "CANCELLED", isFinal: true, metadata: null },
+    },
+    initialState: "PROPOSED",
+    transitions: [
+        {
+            from: "PROPOSED",
+            to: "OPEN",
+            eventName: "open",
+            guard: { "==": [1, 1] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    { status: "OPEN", openedAt: { var: "$timestamp" } },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "PROPOSED",
+            to: "CANCELLED",
+            eventName: "cancel",
+            guard: { "==": [1, 1] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    { status: "CANCELLED", cancelledAt: { var: "$timestamp" } },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "OPEN",
+            to: "OPEN",
+            eventName: "commit",
+            guard: { ">": [{ var: "event.amount" }, 0] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        totalCommitted: {
+                            "+": [{ var: "state.totalCommitted" }, { var: "event.amount" }],
+                        },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "OPEN",
+            to: "CLOSED",
+            eventName: "close",
+            guard: { "==": [1, 1] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    { status: "CLOSED", closedAt: { var: "$timestamp" } },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "CLOSED",
+            to: "SETTLED",
+            eventName: "settle",
+            guard: { "==": [1, 1] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    { status: "SETTLED", settledAt: { var: "$timestamp" } },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "CLOSED",
+            to: "CANCELLED",
+            eventName: "cancel",
+            guard: { "==": [1, 1] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    { status: "CANCELLED", cancelledAt: { var: "$timestamp" } },
+                ],
+            },
+            dependencies: [],
+        },
+    ],
+});

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

@@ -0,0 +1,21 @@
+/**
+ * Oracle Application — Backward Compatibility Shim
+ *
+ * ⚠️ DEPRECATED: Oracle types have been unified into the Identity app.
+ * Import from `@ottochain/sdk/apps/identity` instead.
+ *
+ * @deprecated Use `@ottochain/sdk/apps/identity`
+ * @packageDocumentation
+ */
+export { IdentityState as OracleState, Reputation as OracleReputation, PenaltyEvent as SlashingEvent, Identity as Oracle, RegisterIdentityRequest as RegisterOracleRequest, ActivateIdentityRequest as ActivateOracleRequest, AddStakeRequest, WithdrawIdentityRequest as WithdrawOracleRequest, IdentityDefinition as OracleDefinition, identityStateFromJSON as oracleStateFromJSON, identityStateToJSON as oracleStateToJSON, } from "../identity/index.js";
+import { getIdentityDefinition } from "../identity/index.js";
+/** @deprecated Use `getIdentityDefinition('oracle')` from `@ottochain/sdk/apps/identity` */
+export function getOracleDefinition(_type) {
+    return getIdentityDefinition("oracle");
+}
+/** @deprecated Use `DEFAULT_REPUTATION_CONFIG` from `@ottochain/sdk/apps/identity` */
+export const DEFAULT_ORACLE_CONFIG = {
+    minStake: 100,
+    baseReputation: 10,
+    reputationDecay: 0.95,
+};

package/dist/esm/generated/index.js

@@ -21,14 +21,19 @@
 export { FiberStatus, AccessControlPolicy, PublicAccess, WhitelistAccess, FiberOwnedAccess, StateMachineDefinition, EmittedEvent, EventReceipt, ScriptInvocation, FiberLogEntry, } from './ottochain/v1/fiber.js';
 export { CreateStateMachine, TransitionStateMachine, ArchiveStateMachine, CreateScript, InvokeScript, OttochainMessage, } from './ottochain/v1/messages.js';
 export { StateMachineFiberRecord, ScriptFiberRecord, FiberCommit, OnChainState, CalculatedState, } from './ottochain/v1/records.js';
-// App: Identity
-export { IdentityType, IdentityState, Platform, PlatformLink, Reputation, PenaltyEvent, Identity, RegisterIdentityRequest, ActivateIdentityRequest, UpdateStakeRequest, ChallengeIdentityRequest, PenalizeIdentityRequest, WithdrawIdentityRequest, IdentityDefinition, } from './ottochain/apps/identity/v1/identity.js';
+// App: Identity (unified in v2.1)
+export { IdentityType, IdentityState, Platform, PlatformLink, Reputation, PenaltyEvent, Identity, RegisterIdentityRequest, ActivateIdentityRequest, LinkPlatformRequest, ChallengeIdentityRequest, AddStakeRequest, WithdrawIdentityRequest, IdentityDefinition, } from './ottochain/apps/identity/v1/identity.js';
+// Legacy aliases for backward compatibility
+export { IdentityState as AgentState } from './ottochain/apps/identity/v1/identity.js';
+export { IdentityState as OracleState } from './ottochain/apps/identity/v1/identity.js';
 export { AttestationType, ReputationDelta, Attestation, VouchRequest, ChallengeRequest, ReputationConfig, } from './ottochain/apps/identity/v1/attestation.js';
 // App: Contracts
 export { ContractState, Contract, ProposeContractRequest, AcceptContractRequest, CompleteContractRequest, RejectContractRequest, DisputeContractRequest, ContractDefinition, } from './ottochain/apps/contracts/v1/contract.js';
 // App: Markets
 export { MarketType, MarketState, Commitment, Resolution, Market, CreateMarketRequest, CommitToMarketRequest, SubmitResolutionRequest, CancelMarketRequest, MarketDefinition, } from './ottochain/apps/markets/v1/market.js';
-// Note: Oracle types merged into Identity (IdentityType.ORACLE)
+// App: Oracles - REMOVED in v2.1 (absorbed into identity)
+// OracleState is now an alias for IdentityState (see above)
+// Oracle-specific messages moved to identity.proto
 // App: Governance
 export { DAOType, DAOStatus, ProposalStatus, VoteChoice, DAOMetadata, Proposal, Vote, VoteTally, SingleOwnerDAO, SingleOwnerAction, OwnershipTransfer, MultisigDAO, MultisigAction, TokenDAO, TokenProposalResult, ThresholdDAO, ThresholdVotes, ThresholdHistoryEntry, CreateDAORequest, ProposeRequest, VoteRequest, ExecuteRequest, } from './ottochain/apps/governance/v1/governance.js';
 // App: Corporate