@ottochain/sdk 2.4.0 → 2.5.0

package/dist/esm/apps/lending/state-machines/lending-zk-loan.js

@@ -1,4 +1,4 @@
-import { defineFiberApp } from "../../../schema/fiber-app.js";
+import { defineFiberApp } from '../../../schema/fiber-app.js';
 /**
  * Privacy-preserving zk-loan — a private-finance lending fiber modeled on Midnight's
  * zkLoan example, integrated with OttoChain's asset subsystem.
@@ -32,251 +32,262 @@ import { defineFiberApp } from "../../../schema/fiber-app.js";
  */
 export const lendingZkLoanDef = defineFiberApp({
     metadata: {
-        name: "LendingZkLoan",
-        app: "lending",
-        type: "zkLoan",
-        version: "1.0.0",
-        description: "Privacy-preserving collateralized loan: the borrower proves loan eligibility (collateral coverage / credit-score floor) in zero-knowledge without revealing the financials; collateral, principal and repayment are asset-subsystem tokens driven by the loan lifecycle.",
+        name: 'LendingZkLoan',
+        app: 'lending',
+        type: 'zkLoan',
+        version: '1.0.0',
+        description: 'Privacy-preserving collateralized loan: the borrower proves loan eligibility (collateral coverage / credit-score floor) in zero-knowledge without revealing the financials; collateral, principal and repayment are asset-subsystem tokens driven by the loan lifecycle.',
         crossReferences: {
             borrowerIdentityId: "Links to the borrower's IdentityAgent",
             lenderIdentityId: "Links to the lender's IdentityAgent (loan originator)",
             collateralAssetId: "Asset instance locked as collateral (held by the loan's escrow fiber)",
-            debtAssetId: "Asset instance representing the outstanding loan principal/debt minted to the borrower",
+            debtAssetId: 'Asset instance representing the outstanding loan principal/debt minted to the borrower',
         },
     },
     createSchema: {
         required: [
-            "borrower",
-            "lender",
-            "principalAmount",
-            "collateralAssetId",
-            "collateralPolicy",
-            "debtPolicy",
-            "lendingRuleVKey",
-            "lendingRuleLogicHash",
-            "keccakTrue",
+            'borrower',
+            'lender',
+            'principalAmount',
+            'collateralAssetId',
+            'collateralPolicy',
+            'debtPolicy',
+            'lendingRuleVKey',
+            'lendingRuleLogicHash',
+            'keccakTrue',
         ],
         properties: {
             borrower: {
-                type: "address",
-                description: "DAG address of the borrower",
+                type: 'address',
+                description: 'DAG address of the borrower',
                 immutable: true,
             },
             lender: {
-                type: "address",
-                description: "DAG address of the lender / loan originator",
+                type: 'address',
+                description: 'DAG address of the lender / loan originator',
                 immutable: true,
             },
             principalAmount: {
-                type: "integer",
-                description: "PUBLIC loan principal (asset minor-units). The financials backing eligibility stay private.",
+                type: 'integer',
+                description: 'PUBLIC loan principal (asset minor-units). The financials backing eligibility stay private.',
                 minimum: 1,
                 immutable: true,
             },
             collateralAssetId: {
-                type: "uuid",
-                description: "Asset instance id pledged as collateral (its private valuation is never revealed).",
+                type: 'uuid',
+                description: 'Asset instance id pledged as collateral (its private valuation is never revealed).',
                 immutable: true,
             },
             collateralPolicy: {
-                type: "string",
+                type: 'string',
                 description: "Collateral asset policy name (e.g. 'collateral-vault-v1.asset').",
                 immutable: true,
             },
             debtPolicy: {
-                type: "string",
+                type: 'string',
                 description: "Debt/loan-token asset policy name (e.g. 'loan-debt-v1.asset').",
                 immutable: true,
             },
             escrowFiberId: {
-                type: "uuid",
-                description: "Fiber that custodies the locked collateral (AssetHolder.Fiber). Defaults to this loan fiber.",
+                type: 'uuid',
+                description: 'Fiber that custodies the locked collateral (AssetHolder.Fiber). Defaults to this loan fiber.',
             },
             lendingRuleVKey: {
-                type: "hash",
-                description: "PINNED SP1 program verifying key (bytes32, 0x-hex) for the eligibility circuit.",
+                type: 'hash',
+                description: 'PINNED SP1 program verifying key (bytes32, 0x-hex) for the eligibility circuit.',
                 immutable: true,
             },
             lendingRuleLogicHash: {
-                type: "hash",
+                type: 'hash',
                 description: "PINNED logicHash of the public lending rule = keccak256(canonicalize(rule)). The proof's committed exprHash must equal this.",
                 immutable: true,
             },
             keccakTrue: {
-                type: "hash",
+                type: 'hash',
                 description: "PINNED keccak256(canonicalize(true)) — the outputHash a 'rule returned true' proof must commit.",
                 immutable: true,
             },
             dueOrdinal: {
-                type: "integer",
-                description: "Optional snapshot ordinal by which repayment is due.",
+                type: 'integer',
+                description: 'Optional snapshot ordinal by which repayment is due.',
                 minimum: 0,
             },
         },
     },
     stateSchema: {
         properties: {
-            status: { type: "string", computed: true },
-            borrower: { type: "address", immutable: true },
-            lender: { type: "address", immutable: true },
-            principalAmount: { type: "integer", immutable: true },
-            collateralAssetId: { type: "uuid", immutable: true },
-            collateralPolicy: { type: "string", immutable: true },
-            debtPolicy: { type: "string", immutable: true },
-            escrowFiberId: { type: "uuid" },
-            debtAssetId: { type: "uuid", computed: true },
-            lendingRuleVKey: { type: "hash", immutable: true },
-            lendingRuleLogicHash: { type: "hash", immutable: true },
-            keccakTrue: { type: "hash", immutable: true },
-            dueOrdinal: { type: "integer" },
-            lockedAt: { type: "integer", computed: true },
-            originatedAt: { type: "integer", computed: true },
-            repaidAt: { type: "integer", computed: true },
-            defaultedAt: { type: "integer", computed: true },
-            liquidatedAt: { type: "integer", computed: true },
+            status: { type: 'string', computed: true },
+            borrower: { type: 'address', immutable: true },
+            lender: { type: 'address', immutable: true },
+            principalAmount: { type: 'integer', immutable: true },
+            collateralAssetId: { type: 'uuid', immutable: true },
+            collateralPolicy: { type: 'string', immutable: true },
+            debtPolicy: { type: 'string', immutable: true },
+            escrowFiberId: { type: 'uuid' },
+            debtAssetId: { type: 'uuid', computed: true },
+            lendingRuleVKey: { type: 'hash', immutable: true },
+            lendingRuleLogicHash: { type: 'hash', immutable: true },
+            keccakTrue: { type: 'hash', immutable: true },
+            dueOrdinal: { type: 'integer' },
+            lockedAt: { type: 'integer', computed: true },
+            originatedAt: { type: 'integer', computed: true },
+            repaidAt: { type: 'integer', computed: true },
+            defaultedAt: { type: 'integer', computed: true },
+            liquidatedAt: { type: 'integer', computed: true },
         },
     },
     eventSchemas: {
         lock_collateral: {
-            description: "Borrower locks the pledged collateral asset into the loan escrow fiber (drives an asset Transfer/Mint into AssetHolder.Fiber).",
+            description: 'Borrower locks the pledged collateral asset into the loan escrow fiber (drives an asset Transfer/Mint into AssetHolder.Fiber).',
         },
         originate: {
             description: "Lender originates the loan after the borrower's zk eligibility proof verifies. The witness carries the SP1-Groth16 {publicValues, proof}; the guard binds them to the pinned public lending rule. The effect mints the debt/principal asset to the borrower.",
-            required: ["witness", "debtAssetId"],
+            required: ['witness', 'debtAssetId'],
             properties: {
                 witness: {
-                    type: "object",
-                    description: "Eligibility-proof witness: { publicValues: 0x-hex, proof: 0x-hex }. Exposed to the guard under the reserved `witness` key.",
+                    type: 'object',
+                    description: 'Eligibility-proof witness: { publicValues: 0x-hex, proof: 0x-hex }. Exposed to the guard under the reserved `witness` key.',
                     properties: {
-                        publicValues: { type: "string", description: "abi_encode(JlvmPublicValues), 0x-hex." },
-                        proof: { type: "string", description: "SP1-Groth16 proof bytes, 0x-hex." },
+                        publicValues: {
+                            type: 'string',
+                            description: 'abi_encode(JlvmPublicValues), 0x-hex.',
+                        },
+                        proof: {
+                            type: 'string',
+                            description: 'SP1-Groth16 proof bytes, 0x-hex.',
+                        },
                     },
-                    required: ["publicValues", "proof"],
+                    required: ['publicValues', 'proof'],
                 },
                 debtAssetId: {
-                    type: "uuid",
-                    description: "Asset instance id for the debt/principal token minted to the borrower.",
+                    type: 'uuid',
+                    description: 'Asset instance id for the debt/principal token minted to the borrower.',
                 },
             },
         },
         repay: {
-            description: "Borrower repays the principal (drives a Burn of the debt token); on success the collateral is released back to the borrower via the escrow fiber.",
+            description: 'Borrower repays the principal (drives a Burn of the debt token); on success the collateral is released back to the borrower via the escrow fiber.',
         },
         default_loan: {
-            description: "Mark the loan defaulted once past due (drives the collateral toward liquidation).",
+            description: 'Mark the loan defaulted once past due (drives the collateral toward liquidation).',
         },
         liquidate: {
-            description: "Lender liquidates a defaulted loan: the locked collateral is transferred to the lender via the escrow fiber.",
+            description: 'Lender liquidates a defaulted loan: the locked collateral is transferred to the lender via the escrow fiber.',
         },
         cancel: {
-            description: "Cancel a loan request before collateral is locked.",
-            properties: { reason: { type: "string" } },
+            description: 'Cancel a loan request before collateral is locked.',
+            properties: { reason: { type: 'string' } },
         },
     },
     states: {
         REQUESTED: {
-            id: "REQUESTED",
+            id: 'REQUESTED',
             isFinal: false,
             metadata: {
-                label: "Requested",
-                description: "Loan requested; collateral not yet locked, eligibility not yet proven.",
-                category: "initial",
+                label: 'Requested',
+                description: 'Loan requested; collateral not yet locked, eligibility not yet proven.',
+                category: 'initial',
             },
         },
         COLLATERAL_LOCKED: {
-            id: "COLLATERAL_LOCKED",
+            id: 'COLLATERAL_LOCKED',
             isFinal: false,
             metadata: {
-                label: "Collateral Locked",
+                label: 'Collateral Locked',
                 description: "Collateral asset escrowed in the loan fiber; awaiting the lender's zk-gated origination.",
-                category: "pending",
+                category: 'pending',
             },
         },
         ACTIVE: {
-            id: "ACTIVE",
+            id: 'ACTIVE',
             isFinal: false,
             metadata: {
-                label: "Active",
-                description: "Loan originated (eligibility proven in zk); principal minted to the borrower.",
-                category: "active",
+                label: 'Active',
+                description: 'Loan originated (eligibility proven in zk); principal minted to the borrower.',
+                category: 'active',
             },
         },
         DEFAULTED: {
-            id: "DEFAULTED",
+            id: 'DEFAULTED',
             isFinal: false,
             metadata: {
-                label: "Defaulted",
-                description: "Loan past due and unpaid; collateral pending liquidation.",
-                category: "pending",
+                label: 'Defaulted',
+                description: 'Loan past due and unpaid; collateral pending liquidation.',
+                category: 'pending',
             },
         },
         REPAID: {
-            id: "REPAID",
+            id: 'REPAID',
             isFinal: true,
             metadata: {
-                label: "Repaid",
-                description: "Principal repaid (debt burned) and collateral released to the borrower.",
-                category: "terminal",
+                label: 'Repaid',
+                description: 'Principal repaid (debt burned) and collateral released to the borrower.',
+                category: 'terminal',
             },
         },
         LIQUIDATED: {
-            id: "LIQUIDATED",
+            id: 'LIQUIDATED',
             isFinal: true,
             metadata: {
-                label: "Liquidated",
-                description: "Defaulted loan settled by transferring the collateral to the lender.",
-                category: "terminal",
+                label: 'Liquidated',
+                description: 'Defaulted loan settled by transferring the collateral to the lender.',
+                category: 'terminal',
             },
         },
         CANCELLED: {
-            id: "CANCELLED",
+            id: 'CANCELLED',
             isFinal: true,
             metadata: {
-                label: "Cancelled",
-                description: "Loan request cancelled before any collateral was locked.",
-                category: "terminal",
+                label: 'Cancelled',
+                description: 'Loan request cancelled before any collateral was locked.',
+                category: 'terminal',
             },
         },
     },
-    initialState: "REQUESTED",
+    initialState: 'REQUESTED',
     transitions: [
         // Borrower locks collateral into the escrow fiber.
         {
-            from: "REQUESTED",
-            to: "COLLATERAL_LOCKED",
-            eventName: "lock_collateral",
+            from: 'REQUESTED',
+            to: 'COLLATERAL_LOCKED',
+            eventName: 'lock_collateral',
             guard: {
                 and: [
-                    { in: [{ var: "state.borrower" }, { map: [{ var: "proofs" }, { var: "address" }] }] },
-                    { "===": [{ var: "event.assetId" }, { var: "state.collateralAssetId" }] },
+                    {
+                        in: [{ var: 'state.borrower' }, { map: [{ var: 'proofs' }, { var: 'address' }] }],
+                    },
+                    {
+                        '===': [{ var: 'event.assetId' }, { var: 'state.collateralAssetId' }],
+                    },
                 ],
             },
             effect: {
-                merge: [
-                    { var: "state" },
-                    { status: "COLLATERAL_LOCKED", lockedAt: { var: "$ordinal" } },
-                ],
+                merge: [{ var: 'state' }, { status: 'COLLATERAL_LOCKED', lockedAt: { var: '$ordinal' } }],
             },
             dependencies: [],
         },
         // Cancel a request before any collateral is locked.
         {
-            from: "REQUESTED",
-            to: "CANCELLED",
-            eventName: "cancel",
+            from: 'REQUESTED',
+            to: 'CANCELLED',
+            eventName: 'cancel',
             guard: {
                 or: [
-                    { in: [{ var: "state.borrower" }, { map: [{ var: "proofs" }, { var: "address" }] }] },
-                    { in: [{ var: "state.lender" }, { map: [{ var: "proofs" }, { var: "address" }] }] },
+                    {
+                        in: [{ var: 'state.borrower' }, { map: [{ var: 'proofs' }, { var: 'address' }] }],
+                    },
+                    {
+                        in: [{ var: 'state.lender' }, { map: [{ var: 'proofs' }, { var: 'address' }] }],
+                    },
                 ],
             },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "CANCELLED",
-                        cancelledAt: { var: "$ordinal" },
-                        reason: { var: "event.reason" },
+                        status: 'CANCELLED',
+                        cancelledAt: { var: '$ordinal' },
+                        reason: { var: 'event.reason' },
                     },
                 ],
             },
@@ -296,33 +307,39 @@ export const lendingZkLoanDef = defineFiberApp({
         //   4. outputHash == keccakTrue                          — the rule evaluated to true
         //   5. ok bit (last hex pair of word 3) == "01"          — the JLVM run did not error
         {
-            from: "COLLATERAL_LOCKED",
-            to: "ACTIVE",
-            eventName: "originate",
+            from: 'COLLATERAL_LOCKED',
+            to: 'ACTIVE',
+            eventName: 'originate',
             guard: {
                 and: [
-                    { in: [{ var: "state.lender" }, { map: [{ var: "proofs" }, { var: "address" }] }] },
+                    {
+                        in: [{ var: 'state.lender' }, { map: [{ var: 'proofs' }, { var: 'address' }] }],
+                    },
                     {
                         groth16_verify: [
-                            { var: "state.lendingRuleVKey" },
-                            { var: "event.witness.publicValues" },
-                            { var: "event.witness.proof" },
+                            { var: 'state.lendingRuleVKey' },
+                            { var: 'event.witness.publicValues' },
+                            { var: 'event.witness.proof' },
                         ],
                     },
                     {
-                        "===": [
-                            { cat: ["0x", { substr: [{ var: "event.witness.publicValues" }, 2, 64] }] },
-                            { var: "state.lendingRuleLogicHash" },
+                        '===': [
+                            {
+                                cat: ['0x', { substr: [{ var: 'event.witness.publicValues' }, 2, 64] }],
+                            },
+                            { var: 'state.lendingRuleLogicHash' },
                         ],
                     },
                     {
-                        "===": [
-                            { cat: ["0x", { substr: [{ var: "event.witness.publicValues" }, 130, 64] }] },
-                            { var: "state.keccakTrue" },
+                        '===': [
+                            {
+                                cat: ['0x', { substr: [{ var: 'event.witness.publicValues' }, 130, 64] }],
+                            },
+                            { var: 'state.keccakTrue' },
                         ],
                     },
                     {
-                        "===": [{ substr: [{ var: "event.witness.publicValues" }, 256, 2] }, "01"],
+                        '===': [{ substr: [{ var: 'event.witness.publicValues' }, 256, 2] }, '01'],
                     },
                 ],
             },
@@ -330,11 +347,11 @@ export const lendingZkLoanDef = defineFiberApp({
             // debt asset id, and activates the loan.
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "ACTIVE",
-                        originatedAt: { var: "$ordinal" },
-                        debtAssetId: { var: "event.debtAssetId" },
+                        status: 'ACTIVE',
+                        originatedAt: { var: '$ordinal' },
+                        debtAssetId: { var: 'event.debtAssetId' },
                     },
                 ],
             },
@@ -342,22 +359,27 @@ export const lendingZkLoanDef = defineFiberApp({
         },
         // Borrower repays — debt is burned, collateral released back to the borrower.
         {
-            from: "ACTIVE",
-            to: "REPAID",
-            eventName: "repay",
-            guard: { in: [{ var: "state.borrower" }, { map: [{ var: "proofs" }, { var: "address" }] }] },
+            from: 'ACTIVE',
+            to: 'REPAID',
+            eventName: 'repay',
+            guard: {
+                in: [{ var: 'state.borrower' }, { map: [{ var: 'proofs' }, { var: 'address' }] }],
+            },
             // Release the escrowed collateral back to the borrower. The loan fiber HOLDS the collateral
             // (locked as AssetHolder.Fiber), so it emits the reserved `_transferAsset` directive from inside
             // the effect — the engine extracts `_`-prefixed keys (it is NOT merged into state). A transition-
             // level `emits` block is silently dropped by toProtoDefinition, which would strand the collateral.
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "REPAID",
-                        repaidAt: { var: "$ordinal" },
+                        status: 'REPAID',
+                        repaidAt: { var: '$ordinal' },
                         _transferAsset: [
-                            { assetId: { var: "state.collateralAssetId" }, recipient: { var: "state.borrower" } },
+                            {
+                                assetId: { var: 'state.collateralAssetId' },
+                                recipient: { Wallet: { address: { var: 'state.borrower' } } },
+                            },
                         ],
                     },
                 ],
@@ -366,39 +388,38 @@ export const lendingZkLoanDef = defineFiberApp({
         },
         // Loan goes past due → defaulted.
         {
-            from: "ACTIVE",
-            to: "DEFAULTED",
-            eventName: "default_loan",
+            from: 'ACTIVE',
+            to: 'DEFAULTED',
+            eventName: 'default_loan',
             guard: {
-                and: [
-                    { var: "state.dueOrdinal" },
-                    { ">=": [{ var: "$ordinal" }, { var: "state.dueOrdinal" }] },
-                ],
+                and: [{ var: 'state.dueOrdinal' }, { '>=': [{ var: '$ordinal' }, { var: 'state.dueOrdinal' }] }],
             },
             effect: {
-                merge: [
-                    { var: "state" },
-                    { status: "DEFAULTED", defaultedAt: { var: "$ordinal" } },
-                ],
+                merge: [{ var: 'state' }, { status: 'DEFAULTED', defaultedAt: { var: '$ordinal' } }],
             },
             dependencies: [],
         },
         // Lender liquidates a defaulted loan — collateral transferred to the lender.
         {
-            from: "DEFAULTED",
-            to: "LIQUIDATED",
-            eventName: "liquidate",
-            guard: { in: [{ var: "state.lender" }, { map: [{ var: "proofs" }, { var: "address" }] }] },
+            from: 'DEFAULTED',
+            to: 'LIQUIDATED',
+            eventName: 'liquidate',
+            guard: {
+                in: [{ var: 'state.lender' }, { map: [{ var: 'proofs' }, { var: 'address' }] }],
+            },
             // Transfer the escrowed collateral to the lender via the reserved `_transferAsset` directive
             // inside the effect (the loan fiber holds it). A transition-level `emits` block is dropped by the engine.
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "LIQUIDATED",
-                        liquidatedAt: { var: "$ordinal" },
+                        status: 'LIQUIDATED',
+                        liquidatedAt: { var: '$ordinal' },
                         _transferAsset: [
-                            { assetId: { var: "state.collateralAssetId" }, recipient: { var: "state.lender" } },
+                            {
+                                assetId: { var: 'state.collateralAssetId' },
+                                recipient: { Wallet: { address: { var: 'state.lender' } } },
+                            },
                         ],
                     },
                 ],

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

@@ -22,14 +22,14 @@
 // Re-export generated protobuf types (source of truth).
 // The nested lifecycle/kind enums dropped their app prefix in the proto; under
 // this app-scoped entrypoint they are unambiguously Type / State.
-export { Type, State, Commitment, Resolution, Market, CreateMarketRequest, CommitToMarketRequest, SubmitResolutionRequest, CancelMarketRequest, MarketDefinition, typeFromJSON, typeToJSON, stateFromJSON, stateToJSON, } from "../../generated/ottochain/apps/markets/v1/market.js";
+export { Type, State, Commitment, Resolution, Market, CreateMarketRequest, CommitToMarketRequest, SubmitResolutionRequest, CancelMarketRequest, MarketDefinition, typeFromJSON, typeToJSON, stateFromJSON, stateToJSON, } from '../../generated/ottochain/apps/markets/v1/market.js';
 // Deprecated app-prefixed aliases (renamed to Type / State); kept for compat.
-export { Type as MarketType, State as MarketState, typeFromJSON as marketTypeFromJSON, typeToJSON as marketTypeToJSON, stateFromJSON as marketStateFromJSON, stateToJSON as marketStateToJSON, } from "../../generated/ottochain/apps/markets/v1/market.js";
+export { Type as MarketType, State as MarketState, typeFromJSON as marketTypeFromJSON, typeToJSON as marketTypeToJSON, stateFromJSON as marketStateFromJSON, stateToJSON as marketStateToJSON, } from '../../generated/ottochain/apps/markets/v1/market.js';
 // ---------------------------------------------------------------------------
 // State Machine Definitions (generated from JSON at build time)
 // ---------------------------------------------------------------------------
-import { marketUniversalDef, marketPredictionDef, marketAuctionDef, marketCrowdfundDef, marketGroupBuyDef, } from "./state-machines/index.js";
-export { marketUniversalDef, marketPredictionDef, marketAuctionDef, marketCrowdfundDef, marketGroupBuyDef, };
+import { marketUniversalDef, marketPredictionDef, marketAuctionDef, marketCrowdfundDef, marketGroupBuyDef, } from './state-machines/index.js';
+export { marketUniversalDef, marketPredictionDef, marketAuctionDef, marketCrowdfundDef, marketGroupBuyDef };
 /** All market state machine definitions */
 export const MARKETS_DEFINITIONS = {
     universal: marketUniversalDef,
@@ -42,6 +42,6 @@ export const MARKETS_DEFINITIONS = {
  * Get a market state machine definition by type.
  * @param type - 'universal' | 'prediction' | 'auction' | 'crowdfund' | 'groupBuy' (default: 'universal')
  */
-export function getMarketDefinition(type = "universal") {
+export function getMarketDefinition(type = 'universal') {
     return MARKETS_DEFINITIONS[type];
 }