@ottochain/sdk 1.7.0-beta.2 → 2.1.0

package/dist/types/apps/markets/state-machines/market-universal.d.ts

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

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

@@ -0,0 +1,18 @@
+/**
+ * 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";
+/** @deprecated Use `getIdentityDefinition('oracle')` from `@ottochain/sdk/apps/identity` */
+export declare function getOracleDefinition(_type?: string): unknown;
+/** @deprecated Use `DEFAULT_REPUTATION_CONFIG` from `@ottochain/sdk/apps/identity` */
+export declare const DEFAULT_ORACLE_CONFIG: {
+    readonly minStake: 100;
+    readonly baseReputation: 10;
+    readonly reputationDecay: 0.95;
+};

package/dist/types/generated/index.d.ts

@@ -19,7 +19,9 @@
 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';
-export { IdentityType, IdentityState, Platform, PlatformLink, Reputation, PenaltyEvent, Identity, RegisterIdentityRequest, ActivateIdentityRequest, UpdateStakeRequest, ChallengeIdentityRequest, PenalizeIdentityRequest, WithdrawIdentityRequest, IdentityDefinition, } from './ottochain/apps/identity/v1/identity.js';
+export { IdentityType, IdentityState, Platform, PlatformLink, Reputation, PenaltyEvent, Identity, RegisterIdentityRequest, ActivateIdentityRequest, LinkPlatformRequest, ChallengeIdentityRequest, AddStakeRequest, WithdrawIdentityRequest, IdentityDefinition, } from './ottochain/apps/identity/v1/identity.js';
+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';
 export { ContractState, Contract, ProposeContractRequest, AcceptContractRequest, CompleteContractRequest, RejectContractRequest, DisputeContractRequest, ContractDefinition, } from './ottochain/apps/contracts/v1/contract.js';
 export { MarketType, MarketState, Commitment, Resolution, Market, CreateMarketRequest, CommitToMarketRequest, SubmitResolutionRequest, CancelMarketRequest, MarketDefinition, } from './ottochain/apps/markets/v1/market.js';

package/dist/types/generated/ottochain/apps/identity/v1/identity.d.ts

@@ -1,37 +1,42 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 export declare const protobufPackage = "ottochain.apps.identity.v1";
-/** Type of identity */
+/** Identity type - determines which state machine variant applies */
 export declare enum IdentityType {
     IDENTITY_TYPE_UNSPECIFIED = "IDENTITY_TYPE_UNSPECIFIED",
-    /** IDENTITY_TYPE_AGENT - General agent identity */
+    /** IDENTITY_TYPE_AGENT - AI agent identity */
     IDENTITY_TYPE_AGENT = "IDENTITY_TYPE_AGENT",
-    /** IDENTITY_TYPE_ORACLE - Oracle service provider */
+    /** IDENTITY_TYPE_ORACLE - Oracle service identity */
     IDENTITY_TYPE_ORACLE = "IDENTITY_TYPE_ORACLE",
-    /** IDENTITY_TYPE_SERVICE - Automated service identity */
+    /** IDENTITY_TYPE_SERVICE - Generic service identity */
     IDENTITY_TYPE_SERVICE = "IDENTITY_TYPE_SERVICE",
     UNRECOGNIZED = "UNRECOGNIZED"
 }
 export declare function identityTypeFromJSON(object: any): IdentityType;
 export declare function identityTypeToJSON(object: IdentityType): string;
 export declare function identityTypeToNumber(object: IdentityType): number;
-/** Identity lifecycle states (shared across all identity types) */
+/**
+ * Unified identity lifecycle states
+ * Shared across all identity types with type-specific transitions
+ */
 export declare enum IdentityState {
     IDENTITY_STATE_UNSPECIFIED = "IDENTITY_STATE_UNSPECIFIED",
     /** IDENTITY_STATE_UNREGISTERED - Not yet registered (oracle initial) */
     IDENTITY_STATE_UNREGISTERED = "IDENTITY_STATE_UNREGISTERED",
-    /** IDENTITY_STATE_REGISTERED - Registered, awaiting activation */
+    /** IDENTITY_STATE_REGISTERED - Registered, pending activation */
     IDENTITY_STATE_REGISTERED = "IDENTITY_STATE_REGISTERED",
     /** IDENTITY_STATE_ACTIVE - Active and participating */
     IDENTITY_STATE_ACTIVE = "IDENTITY_STATE_ACTIVE",
-    /** IDENTITY_STATE_INACTIVE - Temporarily inactive */
-    IDENTITY_STATE_INACTIVE = "IDENTITY_STATE_INACTIVE",
-    /** IDENTITY_STATE_CHALLENGED - Under dispute/challenge */
+    /** IDENTITY_STATE_CHALLENGED - Under dispute (agent-specific) */
     IDENTITY_STATE_CHALLENGED = "IDENTITY_STATE_CHALLENGED",
-    /** IDENTITY_STATE_SUSPENDED - Penalized (slashed for oracles) */
+    /** IDENTITY_STATE_SUSPENDED - Temporarily suspended */
     IDENTITY_STATE_SUSPENDED = "IDENTITY_STATE_SUSPENDED",
     /** IDENTITY_STATE_PROBATION - Recovering from suspension */
     IDENTITY_STATE_PROBATION = "IDENTITY_STATE_PROBATION",
-    /** IDENTITY_STATE_WITHDRAWN - Voluntarily exited (terminal) */
+    /** IDENTITY_STATE_SLASHED - Penalized (oracle-specific) */
+    IDENTITY_STATE_SLASHED = "IDENTITY_STATE_SLASHED",
+    /** IDENTITY_STATE_INACTIVE - Voluntarily inactive but can reactivate */
+    IDENTITY_STATE_INACTIVE = "IDENTITY_STATE_INACTIVE",
+    /** IDENTITY_STATE_WITHDRAWN - Terminal - exited permanently */
     IDENTITY_STATE_WITHDRAWN = "IDENTITY_STATE_WITHDRAWN",
     UNRECOGNIZED = "UNRECOGNIZED"
 }
@@ -59,116 +64,90 @@ export interface PlatformLink {
     linkedAt?: Date | undefined;
     verified: boolean;
 }
-/** Reputation metrics (extended for oracles) */
+/** Reputation metrics (unified for all identity types) */
 export interface Reputation {
     /** Overall reputation score */
     score: number;
-    /** Accuracy for oracles (0-100) */
-    accuracyPercentage: number;
-    /** Total interactions/resolutions */
-    totalInteractions: number;
-    /** Disputes resolved favorably */
+    /** Accuracy percentage (oracles) */
+    accuracy: number;
+    /** Total actions/resolutions */
+    totalActions: number;
     disputesWon: number;
-    /** Disputes resolved against */
     disputesLost: number;
 }
-/** Record of a penalty/slashing event */
+/** Record of a penalty event (slashing, suspension, etc.) */
 export interface PenaltyEvent {
-    /** Description of infraction */
     reason: string;
-    /** Amount penalized */
+    /** Amount slashed (if applicable) */
     amount: number;
     /** Market/contract where infraction occurred */
     contextId: string;
-    /** When penalty occurred */
     timestamp?: Date | undefined;
 }
-/** Universal identity container */
+/** Unified identity on-chain state */
 export interface Identity {
-    /** Unique identifier */
     id: string;
-    /** Type of identity */
-    identityType: IdentityType;
-    /** DAG address */
     address: string;
-    /** Public key */
     publicKey: string;
-    /** Human-readable name */
     displayName: string;
-    /** Current state */
+    identityType: IdentityType;
     state: IdentityState;
-    /** Reputation metrics */
     reputation?: Reputation | undefined;
-    /** Social links (agents) */
-    platformLinks: PlatformLink[];
-    /** Staked amount (oracles) */
+    /** Staked amount (oracles/services) */
     stake: number;
     /** Expertise domains (oracles) */
     domains: string[];
-    /** Slashing/penalty history */
+    platformLinks: PlatformLink[];
     penaltyHistory: PenaltyEvent[];
-    /** Creation timestamp */
     createdAt?: Date | undefined;
-    /** Last update timestamp */
     updatedAt?: Date | undefined;
 }
-/** Register a new identity */
 export interface RegisterIdentityRequest {
     identityType: IdentityType;
     address: string;
     displayName: string;
-    /** For oracles */
+    /** For oracles/services */
     initialStake: number;
     /** For oracles */
     domains: string[];
 }
-/** Activate a registered identity */
 export interface ActivateIdentityRequest {
     identityId: string;
     address: string;
 }
-/** Update identity stake */
-export interface UpdateStakeRequest {
+export interface LinkPlatformRequest {
     identityId: string;
-    address: string;
-    /** Positive to add, negative to withdraw */
-    amount: number;
+    platform: Platform;
+    platformUserId: string;
+    platformUsername: string;
 }
-/** Challenge an identity */
 export interface ChallengeIdentityRequest {
     identityId: string;
-    challenger: string;
+    challengerAddress: string;
     reason: string;
-    evidence: string;
 }
-/** Penalize/slash an identity */
-export interface PenalizeIdentityRequest {
+export interface AddStakeRequest {
     identityId: string;
-    /** Market/contract context */
-    contextId: string;
-    reason: string;
+    address: string;
     amount: number;
 }
-/** Withdraw identity from service */
 export interface WithdrawIdentityRequest {
     identityId: string;
     address: string;
 }
-/** Identity state machine definition */
 export interface IdentityDefinition {
+    /** Configuration for identity state machine */
     identityType: IdentityType;
     /** Default starting reputation */
     initialReputation: number;
-    /** Minimum stake to activate (oracles) */
-    minStake: number;
-    /** Min rep to activate */
+    /** Min rep/stake to activate */
     activationThreshold: number;
-    /** How long suspension lasts */
+    /** Min stake for oracles/services */
+    minStake: number;
     suspensionDurationEpochs: number;
-    /** Min accuracy to remain active (oracles) */
+    slashCooldownEpochs: number;
+    /** Min accuracy for oracles */
     accuracyThreshold: number;
-    /** Max dispute rate before auto-penalty */
-    maxDisputeRate: number;
 }
 export declare const PlatformLink: MessageFns<PlatformLink>;
 export declare const Reputation: MessageFns<Reputation>;
@@ -176,9 +155,9 @@ export declare const PenaltyEvent: MessageFns<PenaltyEvent>;
 export declare const Identity: MessageFns<Identity>;
 export declare const RegisterIdentityRequest: MessageFns<RegisterIdentityRequest>;
 export declare const ActivateIdentityRequest: MessageFns<ActivateIdentityRequest>;
-export declare const UpdateStakeRequest: MessageFns<UpdateStakeRequest>;
+export declare const LinkPlatformRequest: MessageFns<LinkPlatformRequest>;
 export declare const ChallengeIdentityRequest: MessageFns<ChallengeIdentityRequest>;
-export declare const PenalizeIdentityRequest: MessageFns<PenalizeIdentityRequest>;
+export declare const AddStakeRequest: MessageFns<AddStakeRequest>;
 export declare const WithdrawIdentityRequest: MessageFns<WithdrawIdentityRequest>;
 export declare const IdentityDefinition: MessageFns<IdentityDefinition>;
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;

package/dist/types/schema/fiber-app.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Fiber App Definition Schema
+ *
+ * TypeScript-first definitions for fiber apps. This is the source of truth —
+ * no JSON, no code generation. Import types directly.
+ */
+export type SchemaFieldType = 'string' | 'integer' | 'number' | 'boolean' | 'address' | 'uri' | 'timestamp' | 'uuid' | 'hash' | 'object' | 'array';
+export interface SchemaField {
+    type?: SchemaFieldType;
+    description?: string;
+    default?: unknown;
+    maxLength?: number;
+    minLength?: number;
+    minimum?: number;
+    maximum?: number;
+    enum?: readonly string[];
+    pattern?: string;
+    format?: string;
+    nullable?: boolean;
+    immutable?: boolean;
+    computed?: boolean;
+    indexed?: boolean;
+    $ref?: string;
+    items?: SchemaField | {
+        $ref: string;
+    };
+    properties?: Record<string, SchemaField>;
+    required?: readonly string[];
+    additionalProperties?: boolean | SchemaField;
+}
+export interface SchemaDefinition {
+    type: 'object';
+    description?: string;
+    required?: readonly string[];
+    properties: Record<string, SchemaField>;
+    nullable?: boolean;
+}
+export interface EventSchema {
+    description?: string;
+    required?: readonly string[];
+    properties?: Record<string, SchemaField>;
+}
+export interface StateDefinition {
+    id: string;
+    isFinal: boolean;
+    description?: string;
+    metadata?: Record<string, unknown> | null;
+}
+export type JsonLogicRule = Record<string, unknown>;
+export interface EmitSpec {
+    event: string;
+    to?: string;
+    payload?: JsonLogicRule;
+}
+export interface DependencySpec {
+    machine: string;
+    instanceRef: JsonLogicRule;
+    requiredState?: string;
+}
+export interface Transition<TState extends string = string, TEvent extends string = string> {
+    from: TState;
+    to: TState;
+    eventName: TEvent;
+    guard?: JsonLogicRule;
+    effect?: JsonLogicRule;
+    dependencies?: readonly (string | DependencySpec)[];
+    emits?: readonly (string | EmitSpec)[];
+}
+export interface FiberAppMetadata {
+    name: string;
+    app: string;
+    type: string;
+    version: string;
+    description?: string;
+    category?: string;
+    /** Cross-references to other fiber types (informational) */
+    crossReferences?: CrossReferences;
+}
+export interface CrossReferenceSpec {
+    machine: string;
+    description: string;
+    foreignKey?: string;
+}
+export interface CrossReferences {
+    [key: string]: string | CrossReferenceSpec;
+}
+export interface FiberAppDefinition<TState extends string = string, TEvent extends string = string> {
+    metadata: FiberAppMetadata;
+    /** Schema for fiber creation inputs (user-provided) */
+    createSchema?: {
+        required?: readonly string[];
+        properties: Record<string, SchemaField>;
+    };
+    /** Schema for full fiber state (includes computed fields) */
+    stateSchema?: {
+        properties: Record<string, SchemaField>;
+    };
+    /** Schema for each event's payload */
+    eventSchemas?: Record<TEvent, EventSchema>;
+    /** Reusable type definitions */
+    definitions?: Record<string, SchemaDefinition>;
+    /** State machine states */
+    states: Record<TState, StateDefinition>;
+    /** Initial state */
+    initialState: TState;
+    /** State transitions */
+    transitions: readonly Transition<TState, TEvent>[];
+}
+/**
+ * Define a fiber app with full type inference.
+ *
+ * @example
+ * ```ts
+ * const agentDef = defineFiberApp({
+ *   metadata: { name: 'Agent', app: 'identity', type: 'agent', version: '1.0.0' },
+ *   states: {
+ *     REGISTERED: { id: 'REGISTERED', isFinal: false },
+ *     ACTIVE: { id: 'ACTIVE', isFinal: false },
+ *   },
+ *   initialState: 'REGISTERED',
+ *   transitions: [
+ *     { from: 'REGISTERED', to: 'ACTIVE', eventName: 'activate' },
+ *   ],
+ * });
+ * ```
+ */
+export declare function defineFiberApp<TState extends string, TEvent extends string, TDef extends FiberAppDefinition<TState, TEvent>>(definition: TDef): TDef;
+/** Extract state names from a fiber app definition */
+export type StateNames<T extends FiberAppDefinition> = keyof T['states'] & string;
+/** Extract event names from a fiber app definition */
+export type EventNames<T extends FiberAppDefinition> = T['transitions'][number]['eventName'];
+/** Get valid transitions from a given state */
+export declare function getTransitionsFrom<T extends FiberAppDefinition>(def: T, state: StateNames<T>): T['transitions'][number][];
+/** Get valid event names from a given state */
+export declare function getEventsFrom<T extends FiberAppDefinition>(def: T, state: StateNames<T>): string[];
+/** Check if a state is final */
+export declare function isFinalState<T extends FiberAppDefinition>(def: T, state: StateNames<T>): boolean;
+/** Convert definition to plain JSON (for serialization) */
+export declare function toJSON<T extends FiberAppDefinition>(def: T): object;

package/dist/types/schema/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Fiber App Schema
+ */
+export * from './fiber-app.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ottochain/sdk",
-  "version": "1.7.0-beta.2",
+  "version": "2.1.0",
   "description": "TypeScript SDK for ottochain metagraph operations - signing, encoding, and network interactions",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",