@ottochain/sdk 2.0.0 → 2.2.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,10 +19,11 @@
 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 { AgentState, Platform, PlatformLink, AgentIdentity, AgentIdentityDefinition, } from './ottochain/apps/identity/v1/agent.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';
-export { OracleState, OracleReputation, SlashingEvent, Oracle, RegisterOracleRequest, ActivateOracleRequest, AddStakeRequest, WithdrawStakeRequest, SlashOracleRequest, WithdrawOracleRequest, OracleDefinition, } from './ottochain/apps/oracles/v1/oracle.js';
 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';
 export { EntityType, EntityState, DirectorStatus, OfficerStatus, BoardMeetingType, ResolutionStatus, Jurisdiction, ShareClass, CorporateEntity, RegisteredAgent, Incorporator, ShareStructure, CorporateBoard, Director, SeatInfo, QuorumRules, BoardMeeting, MeetingAttendee, CorporateOfficers, Officer, OfficerAction, CorporateShareholders, Shareholder, ShareHolding, CorporateResolution, ResolutionVote, CorporateSecurities, SecurityIssuance, SecurityTransfer, CorporateCompliance, FilingRecord, ComplianceRequirement, CreateEntityRequest, AppointDirectorRequest, IssueSharesRequest, ProposeResolutionRequest, } from './ottochain/apps/corporate/v1/corporate.js';

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

@@ -1,5 +1,5 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
-import { Platform } from "./agent.js";
+import { Platform } from "./identity.js";
 export declare const protobufPackage = "ottochain.apps.identity.v1";
 /** Types of attestations that affect reputation */
 export declare enum AttestationType {

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

@@ -0,0 +1,187 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "ottochain.apps.identity.v1";
+/** Identity type - determines which state machine variant applies */
+export declare enum IdentityType {
+    IDENTITY_TYPE_UNSPECIFIED = "IDENTITY_TYPE_UNSPECIFIED",
+    /** IDENTITY_TYPE_AGENT - AI agent identity */
+    IDENTITY_TYPE_AGENT = "IDENTITY_TYPE_AGENT",
+    /** IDENTITY_TYPE_ORACLE - Oracle service identity */
+    IDENTITY_TYPE_ORACLE = "IDENTITY_TYPE_ORACLE",
+    /** 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;
+/**
+ * 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, pending activation */
+    IDENTITY_STATE_REGISTERED = "IDENTITY_STATE_REGISTERED",
+    /** IDENTITY_STATE_ACTIVE - Active and participating */
+    IDENTITY_STATE_ACTIVE = "IDENTITY_STATE_ACTIVE",
+    /** IDENTITY_STATE_CHALLENGED - Under dispute (agent-specific) */
+    IDENTITY_STATE_CHALLENGED = "IDENTITY_STATE_CHALLENGED",
+    /** 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_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"
+}
+export declare function identityStateFromJSON(object: any): IdentityState;
+export declare function identityStateToJSON(object: IdentityState): string;
+export declare function identityStateToNumber(object: IdentityState): number;
+/** Platform where identity is linked */
+export declare enum Platform {
+    PLATFORM_UNSPECIFIED = "PLATFORM_UNSPECIFIED",
+    PLATFORM_DISCORD = "PLATFORM_DISCORD",
+    PLATFORM_TELEGRAM = "PLATFORM_TELEGRAM",
+    PLATFORM_TWITTER = "PLATFORM_TWITTER",
+    PLATFORM_GITHUB = "PLATFORM_GITHUB",
+    PLATFORM_CUSTOM = "PLATFORM_CUSTOM",
+    UNRECOGNIZED = "UNRECOGNIZED"
+}
+export declare function platformFromJSON(object: any): Platform;
+export declare function platformToJSON(object: Platform): string;
+export declare function platformToNumber(object: Platform): number;
+/** Platform identity link */
+export interface PlatformLink {
+    platform: Platform;
+    platformUserId: string;
+    platformUsername: string;
+    linkedAt?: Date | undefined;
+    verified: boolean;
+}
+/** Reputation metrics (unified for all identity types) */
+export interface Reputation {
+    /** Overall reputation score */
+    score: number;
+    /** Accuracy percentage (oracles) */
+    accuracy: number;
+    /** Total actions/resolutions */
+    totalActions: number;
+    disputesWon: number;
+    disputesLost: number;
+}
+/** Record of a penalty event (slashing, suspension, etc.) */
+export interface PenaltyEvent {
+    reason: string;
+    /** Amount slashed (if applicable) */
+    amount: number;
+    /** Market/contract where infraction occurred */
+    contextId: string;
+    timestamp?: Date | undefined;
+}
+/** Unified identity on-chain state */
+export interface Identity {
+    id: string;
+    address: string;
+    publicKey: string;
+    displayName: string;
+    identityType: IdentityType;
+    state: IdentityState;
+    reputation?: Reputation | undefined;
+    /** Staked amount (oracles/services) */
+    stake: number;
+    /** Expertise domains (oracles) */
+    domains: string[];
+    platformLinks: PlatformLink[];
+    penaltyHistory: PenaltyEvent[];
+    createdAt?: Date | undefined;
+    updatedAt?: Date | undefined;
+}
+export interface RegisterIdentityRequest {
+    identityType: IdentityType;
+    address: string;
+    displayName: string;
+    /** For oracles/services */
+    initialStake: number;
+    /** For oracles */
+    domains: string[];
+}
+export interface ActivateIdentityRequest {
+    identityId: string;
+    address: string;
+}
+export interface LinkPlatformRequest {
+    identityId: string;
+    platform: Platform;
+    platformUserId: string;
+    platformUsername: string;
+}
+export interface ChallengeIdentityRequest {
+    identityId: string;
+    challengerAddress: string;
+    reason: string;
+}
+export interface AddStakeRequest {
+    identityId: string;
+    address: string;
+    amount: number;
+}
+export interface WithdrawIdentityRequest {
+    identityId: string;
+    address: string;
+}
+export interface IdentityDefinition {
+    /** Configuration for identity state machine */
+    identityType: IdentityType;
+    /** Default starting reputation */
+    initialReputation: number;
+    /** Min rep/stake to activate */
+    activationThreshold: number;
+    /** Min stake for oracles/services */
+    minStake: number;
+    suspensionDurationEpochs: number;
+    slashCooldownEpochs: number;
+    /** Min accuracy for oracles */
+    accuracyThreshold: number;
+}
+export declare const PlatformLink: MessageFns<PlatformLink>;
+export declare const Reputation: MessageFns<Reputation>;
+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 LinkPlatformRequest: MessageFns<LinkPlatformRequest>;
+export declare const ChallengeIdentityRequest: MessageFns<ChallengeIdentityRequest>;
+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;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

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

@@ -0,0 +1,172 @@
+/**
+ * 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;
+/**
+ * Proto-compatible state machine definition for metagraph submission.
+ * Matches StateMachineDefinition from ottochain/v1/fiber.proto
+ */
+export interface ProtoStateMachineDefinition {
+    states: Record<string, {
+        id: string;
+        isFinal: boolean;
+    }>;
+    initialState: string;
+    transitions: Array<{
+        from: string;
+        to: string;
+        eventName: string;
+        guard?: unknown;
+        effect?: unknown;
+        dependencies?: unknown[];
+        emits?: unknown[];
+    }>;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Extract proto-compatible StateMachineDefinition from a FiberAppDefinition.
+ * Use this when submitting to the metagraph.
+ *
+ * @example
+ * ```ts
+ * const def = getContractDefinition('agreement');
+ * const protoDef = toProtoDefinition(def);
+ * // Submit protoDef to metagraph
+ * ```
+ */
+export declare function toProtoDefinition<T extends FiberAppDefinition>(def: T): ProtoStateMachineDefinition;

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": "2.0.0",
+  "version": "2.2.0",
   "description": "TypeScript SDK for ottochain metagraph operations - signing, encoding, and network interactions",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",