@ottochain/sdk 1.5.0 → 1.6.0

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

@@ -37,9 +37,9 @@ export const DEFAULT_REPUTATION_CONFIG = {
     challengeThreshold: 5,
 };
 // ---------------------------------------------------------------------------
-// State Machine JSON Definition
+// State Machine Definition (generated from JSON at build time)
 // ---------------------------------------------------------------------------
-import agentIdentityDef from './state-machines/agent-identity.json';
+import { agentIdentityDef } from './state-machines/index.js';
 /**
  * Get the agent identity state machine definition.
  *

package/dist/{cjs/apps/identity/state-machines/agent-identity.json → esm/apps/identity/state-machines/index.js}

@@ -1,4 +1,8 @@
-{
+/**
+ * Auto-generated from JSON state machine definitions.
+ * DO NOT EDIT - regenerate with: npm run prebuild
+ */
+export const agentIdentityDef = {
     "metadata": {
         "name": "AgentIdentity",
         "description": "Decentralized agent identity with reputation tracking and lifecycle management",
@@ -267,4 +271,4 @@
             "dependencies": []
         }
     ]
-}
+};

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

@@ -22,7 +22,7 @@ export { MarketType, MarketState, Commitment, Resolution, Market, CreateMarketRe
 // ---------------------------------------------------------------------------
 // State Machine JSON Definitions
 // ---------------------------------------------------------------------------
-import marketUniversalDef from './state-machines/market-universal.json';
+import { marketUniversalDef } from './state-machines/index.js';
 export const MARKET_DEFINITIONS = {
     Universal: marketUniversalDef,
 };

package/dist/{cjs/apps/markets/state-machines/market-universal.json → esm/apps/markets/state-machines/index.js}

@@ -1,4 +1,8 @@
-{
+/**
+ * Auto-generated from JSON state machine definitions.
+ * DO NOT EDIT - regenerate with: npm run prebuild
+ */
+export const marketUniversalDef = {
     "metadata": {
         "name": "Market",
         "description": "Universal market state machine: predictions, auctions, crowdfunding, group buys",
@@ -618,4 +622,4 @@
             "dependencies": []
         }
     ]
-}
+};

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

@@ -22,7 +22,7 @@ export { OracleState, OracleReputation, SlashingEvent, Oracle, RegisterOracleReq
 // ---------------------------------------------------------------------------
 // State Machine JSON Definitions
 // ---------------------------------------------------------------------------
-import oracleDef from './state-machines/oracle.json';
+import { oracleDef } from './state-machines/index.js';
 export const ORACLE_DEFINITIONS = {
     Oracle: oracleDef,
 };

package/dist/{cjs/apps/oracles/state-machines/oracle.json → esm/apps/oracles/state-machines/index.js}

@@ -1,4 +1,8 @@
-{
+/**
+ * Auto-generated from JSON state machine definitions.
+ * DO NOT EDIT - regenerate with: npm run prebuild
+ */
+export const oracleDef = {
     "metadata": {
         "name": "Oracle",
         "description": "Oracle registration, reputation, and slashing state machine",
@@ -405,4 +409,4 @@
             "dependencies": []
         }
     ]
-}
+};

package/dist/esm/ottochain/index.js

@@ -7,6 +7,8 @@
  */
 // Re-export generated protobuf types (for binary encoding)
 export * as proto from '../generated/index.js';
+// Runtime message type validation
+export { OTTOCHAIN_MESSAGE_TYPES } from './types.js';
 export { decodeOnChainState, getSnapshotOnChainState, getLatestOnChainState, getLogsForFiber, getEventReceipts, getScriptInvocations, extractOnChainState, } from './snapshot.js';
 export { MetagraphClient } from './metagraph-client.js';
 // Transaction helpers (state machine payloads, signing)

package/dist/esm/ottochain/normalize.js

@@ -101,22 +101,36 @@ export function normalizeCreateStateMachine(msg) {
 }
 /**
  * Normalize a TransitionStateMachine message for wire format
+ *
+ * Scala TransitionStateMachine schema:
+ *   fiberId: UUID (required)
+ *   eventName: String (required)
+ *   payload: JsonLogicValue (required)
+ *   targetSequenceNumber: FiberOrdinal (required)
+ *
+ * All fields are required — no Option types, so no null normalization needed.
  */
 export function normalizeTransitionStateMachine(msg) {
     return {
         fiberId: msg.fiberId,
         eventName: msg.eventName,
-        eventData: msg.eventData ?? null,
-        fiberOrdinal: msg.fiberOrdinal,
+        payload: msg.payload,
+        targetSequenceNumber: msg.targetSequenceNumber,
     };
 }
 /**
  * Normalize an ArchiveStateMachine message for wire format
+ *
+ * Scala ArchiveStateMachine schema:
+ *   fiberId: UUID (required)
+ *   targetSequenceNumber: FiberOrdinal (required)
+ *
+ * All fields are required — no Option types, so no null normalization needed.
  */
 export function normalizeArchiveStateMachine(msg) {
     return {
         fiberId: msg.fiberId,
-        reason: msg.reason ?? null,
+        targetSequenceNumber: msg.targetSequenceNumber,
     };
 }
 /**

package/dist/esm/ottochain/types.js

@@ -7,4 +7,14 @@
  * @see modules/models/src/main/scala/xyz/kd5ujc/schema/
  * @packageDocumentation
  */
-export {};
+/**
+ * Names of all valid OttochainMessage types.
+ * Use this for runtime validation (e.g., in API routes).
+ */
+export const OTTOCHAIN_MESSAGE_TYPES = [
+    'CreateStateMachine',
+    'TransitionStateMachine',
+    'ArchiveStateMachine',
+    'CreateScript',
+    'InvokeScript',
+];

package/dist/types/apps/contracts/state-machines/index.d.ts

@@ -0,0 +1,549 @@
+/**
+ * Auto-generated from JSON state machine definitions.
+ * DO NOT EDIT - regenerate with: npm run prebuild
+ */
+export declare const contractDef: {
+    readonly metadata: {
+        readonly name: "Contract";
+        readonly description: "Agreement between two agents with completion attestation and dispute resolution";
+        readonly version: "1.0.0";
+        readonly crossReferences: {
+            readonly proposerIdentityId: "Links to proposer's AgentIdentity fiber";
+            readonly counterpartyIdentityId: "Links to counterparty's AgentIdentity fiber";
+            readonly escrowId: "Links to Escrow if payment is escrowed";
+            readonly arbitrationPoolId: "Links to ArbitrationPool for dispute resolution";
+        };
+    };
+    readonly states: {
+        readonly PROPOSED: {
+            readonly id: "PROPOSED";
+            readonly isFinal: false;
+            readonly metadata: null;
+        };
+        readonly ACTIVE: {
+            readonly id: "ACTIVE";
+            readonly isFinal: false;
+            readonly metadata: null;
+        };
+        readonly COMPLETED: {
+            readonly id: "COMPLETED";
+            readonly isFinal: true;
+            readonly metadata: null;
+        };
+        readonly DISPUTED: {
+            readonly id: "DISPUTED";
+            readonly isFinal: false;
+            readonly metadata: null;
+        };
+        readonly REJECTED: {
+            readonly id: "REJECTED";
+            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: "ACTIVE";
+        readonly eventName: "accept";
+        readonly guard: {
+            readonly "===": readonly [{
+                readonly var: "event.agent";
+            }, {
+                readonly var: "state.counterparty";
+            }];
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly status: "ACTIVE";
+                readonly acceptedAt: {
+                    readonly var: "$timestamp";
+                };
+            }];
+        };
+        readonly dependencies: readonly [];
+    }, {
+        readonly from: "PROPOSED";
+        readonly to: "REJECTED";
+        readonly eventName: "reject";
+        readonly guard: {
+            readonly "===": readonly [{
+                readonly var: "event.agent";
+            }, {
+                readonly var: "state.counterparty";
+            }];
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly status: "REJECTED";
+                readonly rejectedAt: {
+                    readonly var: "$timestamp";
+                };
+                readonly rejectReason: {
+                    readonly var: "event.reason";
+                };
+            }];
+        };
+        readonly dependencies: readonly [];
+    }, {
+        readonly from: "PROPOSED";
+        readonly to: "CANCELLED";
+        readonly eventName: "cancel";
+        readonly guard: {
+            readonly "===": readonly [{
+                readonly var: "event.agent";
+            }, {
+                readonly var: "state.proposer";
+            }];
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly status: "CANCELLED";
+                readonly cancelledAt: {
+                    readonly var: "$timestamp";
+                };
+            }];
+        };
+        readonly dependencies: readonly [];
+    }, {
+        readonly from: "ACTIVE";
+        readonly to: "ACTIVE";
+        readonly eventName: "submit_completion";
+        readonly guard: {
+            readonly and: readonly [{
+                readonly or: readonly [{
+                    readonly "===": readonly [{
+                        readonly var: "event.agent";
+                    }, {
+                        readonly var: "state.proposer";
+                    }];
+                }, {
+                    readonly "===": readonly [{
+                        readonly var: "event.agent";
+                    }, {
+                        readonly var: "state.counterparty";
+                    }];
+                }];
+            }, {
+                readonly "!": readonly [{
+                    readonly in: readonly [{
+                        readonly var: "event.agent";
+                    }, {
+                        readonly map: readonly [{
+                            readonly var: "state.completions";
+                        }, {
+                            readonly var: "agent";
+                        }];
+                    }];
+                }];
+            }];
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly completions: {
+                    readonly cat: readonly [{
+                        readonly var: "state.completions";
+                    }, readonly [{
+                        readonly agent: {
+                            readonly var: "event.agent";
+                        };
+                        readonly proof: {
+                            readonly var: "event.proof";
+                        };
+                        readonly submittedAt: {
+                            readonly var: "$timestamp";
+                        };
+                    }]];
+                };
+            }];
+        };
+        readonly dependencies: readonly [];
+    }, {
+        readonly from: "ACTIVE";
+        readonly to: "COMPLETED";
+        readonly eventName: "finalize";
+        readonly guard: {
+            readonly ">=": readonly [{
+                readonly size: {
+                    readonly var: "state.completions";
+                };
+            }, 2];
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly status: "COMPLETED";
+                readonly completedAt: {
+                    readonly var: "$timestamp";
+                };
+            }];
+        };
+        readonly dependencies: readonly [];
+    }, {
+        readonly from: "ACTIVE";
+        readonly to: "DISPUTED";
+        readonly eventName: "dispute";
+        readonly guard: {
+            readonly or: readonly [{
+                readonly "===": readonly [{
+                    readonly var: "event.agent";
+                }, {
+                    readonly var: "state.proposer";
+                }];
+            }, {
+                readonly "===": readonly [{
+                    readonly var: "event.agent";
+                }, {
+                    readonly var: "state.counterparty";
+                }];
+            }];
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly status: "DISPUTED";
+                readonly disputedAt: {
+                    readonly var: "$timestamp";
+                };
+                readonly disputeReason: {
+                    readonly var: "event.reason";
+                };
+                readonly disputedBy: {
+                    readonly var: "event.agent";
+                };
+            }];
+        };
+        readonly dependencies: readonly [];
+    }, {
+        readonly from: "DISPUTED";
+        readonly to: "COMPLETED";
+        readonly eventName: "resolve";
+        readonly guard: {
+            readonly or: readonly [{
+                readonly var: "event.judicialRuling";
+            }, {
+                readonly and: readonly [{
+                    readonly "===": readonly [{
+                        readonly var: "event.proposerApproves";
+                    }, true];
+                }, {
+                    readonly "===": readonly [{
+                        readonly var: "event.counterpartyApproves";
+                    }, true];
+                }];
+            }];
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly status: "COMPLETED";
+                readonly resolvedAt: {
+                    readonly var: "$timestamp";
+                };
+                readonly resolution: {
+                    readonly var: "event.resolution";
+                };
+                readonly rulingId: {
+                    readonly var: "event.rulingId";
+                };
+            }];
+        };
+        readonly dependencies: readonly [];
+    }];
+};
+export declare const escrowDef: {
+    readonly metadata: {
+        readonly name: "Escrow";
+        readonly description: "Asset custody during multi-party transactions with conditional release";
+        readonly version: "1.0.0";
+        readonly crossReferences: {
+            readonly contractId: "Links to Contract SM that created this escrow";
+            readonly marketId: "Links to Market SM for market-based escrow";
+            readonly insuranceId: "Links to Insurance SM for protected escrow";
+            readonly arbitrationPoolId: "Links to ArbitrationPool for dispute resolution";
+            readonly treasuryId: "Links to Treasury for fee collection";
+        };
+    };
+    readonly states: {
+        readonly CREATED: {
+            readonly id: "CREATED";
+            readonly isFinal: false;
+            readonly metadata: null;
+        };
+        readonly FUNDED: {
+            readonly id: "FUNDED";
+            readonly isFinal: false;
+            readonly metadata: null;
+        };
+        readonly ACTIVE: {
+            readonly id: "ACTIVE";
+            readonly isFinal: false;
+            readonly metadata: null;
+        };
+        readonly RELEASING: {
+            readonly id: "RELEASING";
+            readonly isFinal: false;
+            readonly metadata: null;
+        };
+        readonly DISPUTED: {
+            readonly id: "DISPUTED";
+            readonly isFinal: false;
+            readonly metadata: null;
+        };
+        readonly RELEASED: {
+            readonly id: "RELEASED";
+            readonly isFinal: true;
+            readonly metadata: null;
+        };
+        readonly REFUNDED: {
+            readonly id: "REFUNDED";
+            readonly isFinal: true;
+            readonly metadata: null;
+        };
+        readonly SPLIT: {
+            readonly id: "SPLIT";
+            readonly isFinal: true;
+            readonly metadata: null;
+        };
+    };
+    readonly initialState: "CREATED";
+    readonly transitions: readonly [{
+        readonly from: "CREATED";
+        readonly to: "FUNDED";
+        readonly eventName: "deposit";
+        readonly guard: {
+            readonly and: readonly [{
+                readonly "===": readonly [{
+                    readonly var: "event.agent";
+                }, {
+                    readonly var: "state.depositor";
+                }];
+            }, {
+                readonly ">=": readonly [{
+                    readonly var: "event.amount";
+                }, {
+                    readonly var: "state.requiredAmount";
+                }];
+            }];
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly balance: {
+                    readonly var: "event.amount";
+                };
+                readonly fundedAt: {
+                    readonly var: "$timestamp";
+                };
+            }];
+        };
+        readonly dependencies: readonly [];
+    }, {
+        readonly from: "FUNDED";
+        readonly to: "ACTIVE";
+        readonly eventName: "activate";
+        readonly guard: {
+            readonly or: readonly [{
+                readonly "===": readonly [{
+                    readonly var: "event.agent";
+                }, {
+                    readonly var: "state.beneficiary";
+                }];
+            }, {
+                readonly var: "state.autoActivate";
+            }];
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly activatedAt: {
+                    readonly var: "$timestamp";
+                };
+            }];
+        };
+        readonly dependencies: readonly [];
+    }, {
+        readonly from: "ACTIVE";
+        readonly to: "RELEASING";
+        readonly eventName: "request_release";
+        readonly guard: {
+            readonly "===": readonly [{
+                readonly var: "event.agent";
+            }, {
+                readonly var: "state.beneficiary";
+            }];
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly releaseRequest: {
+                    readonly requestedBy: {
+                        readonly var: "event.agent";
+                    };
+                    readonly amount: {
+                        readonly var: "event.amount";
+                    };
+                    readonly reason: {
+                        readonly var: "event.reason";
+                    };
+                    readonly requestedAt: {
+                        readonly var: "$timestamp";
+                    };
+                };
+                readonly releaseDeadline: {
+                    readonly "+": readonly [{
+                        readonly var: "$timestamp";
+                    }, {
+                        readonly var: "state.releaseWindowMs";
+                    }];
+                };
+            }];
+        };
+        readonly dependencies: readonly [];
+    }, {
+        readonly from: "RELEASING";
+        readonly to: "RELEASED";
+        readonly eventName: "approve_release";
+        readonly guard: {
+            readonly or: readonly [{
+                readonly "===": readonly [{
+                    readonly var: "event.agent";
+                }, {
+                    readonly var: "state.depositor";
+                }];
+            }, {
+                readonly ">=": readonly [{
+                    readonly var: "$timestamp";
+                }, {
+                    readonly var: "state.releaseDeadline";
+                }];
+            }];
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly releasedAt: {
+                    readonly var: "$timestamp";
+                };
+                readonly releasedTo: {
+                    readonly var: "state.beneficiary";
+                };
+            }];
+        };
+        readonly dependencies: readonly [];
+    }, {
+        readonly from: "RELEASING";
+        readonly to: "DISPUTED";
+        readonly eventName: "dispute";
+        readonly guard: {
+            readonly and: readonly [{
+                readonly "===": readonly [{
+                    readonly var: "event.agent";
+                }, {
+                    readonly var: "state.depositor";
+                }];
+            }, {
+                readonly "<": readonly [{
+                    readonly var: "$timestamp";
+                }, {
+                    readonly var: "state.releaseDeadline";
+                }];
+            }];
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly disputedAt: {
+                    readonly var: "$timestamp";
+                };
+            }];
+        };
+        readonly spawns: {
+            readonly sm: "Judiciary";
+            readonly initialData: {
+                readonly caseType: "escrow_dispute";
+                readonly plaintiff: {
+                    readonly var: "state.depositor";
+                };
+                readonly defendant: {
+                    readonly var: "state.beneficiary";
+                };
+                readonly claim: {
+                    readonly escrowId: {
+                        readonly var: "fiberId";
+                    };
+                    readonly amount: {
+                        readonly var: "state.balance";
+                    };
+                };
+            };
+        };
+        readonly dependencies: readonly [];
+    }, {
+        readonly from: "DISPUTED";
+        readonly to: "SPLIT";
+        readonly eventName: "ruling";
+        readonly guard: {
+            readonly var: "event.judicialRuling";
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly splits: {
+                    readonly var: "event.splits";
+                };
+                readonly rulingId: {
+                    readonly var: "event.rulingId";
+                };
+            }];
+        };
+        readonly dependencies: readonly [];
+    }, {
+        readonly from: "ACTIVE";
+        readonly to: "REFUNDED";
+        readonly eventName: "refund";
+        readonly guard: {
+            readonly or: readonly [{
+                readonly var: "event.mutualConsent";
+            }, {
+                readonly ">=": readonly [{
+                    readonly var: "$timestamp";
+                }, {
+                    readonly var: "state.expiresAt";
+                }];
+            }];
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly refundedAt: {
+                    readonly var: "$timestamp";
+                };
+            }];
+        };
+        readonly dependencies: readonly [];
+    }];
+};