@ottochain/sdk 2.3.0 → 2.4.0

package/dist/cjs/apps/identity/state-machines/identity-registry.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identityRegistryDef = void 0;
+const fiber_app_js_1 = require("../../../schema/fiber-app.js");
+const guards_js_1 = require("../../../schema/guards.js");
+/**
+ * Identity Registry — the ecosystem authority & reputation source.
+ *
+ * Aggregates, under a single authority-governed fiber:
+ *  - `reputations: { <address>: int }`  — the public reputation read by reputation-gated apps
+ *    (dao-reputation, credit-scoring) via a declared dependency + the `signerHasReputation` helper.
+ *  - role attestations (ARBITER / SLASHER / ISSUER / BOARD_MEMBER) as FLAT per-role maps
+ *    `{ <address>: true }`, read via the `signerHasRole` helper for judicial / issuance / governance
+ *    authority gates.
+ *
+ * Writes are gated to the registry's pinned `authority` (immutable, set at create) and bound to the
+ * CHAIN-VERIFIED signer via `signerIsParty("state.authority")` — never `event.agent`. Reads happen
+ * cross-fiber: a consumer app declares this registry as a dependency and reads
+ * `machines.<registryDep>.state.reputations` / `.arbiters` / … bound to `proofs[].address`.
+ *
+ * Roles are flat per-role maps rather than a nested `roles[addr][ROLE]` map on purpose: metakit
+ * `get`/`has` on a NULL inner map throw (they are not null-total), so a nested read would error for
+ * any signer with no roles entry — the common case. Flat maps keep both the write (`set`/`unset`) and
+ * the read (`has`) total and fail-closed. New role types are added as new state maps + a cascade arm.
+ *
+ * See docs/design/app-hardening-identity-integration.md §3–§4 and src/schema/guards.ts
+ * (signerHasReputation / signerHasRole).
+ */
+exports.identityRegistryDef = (0, fiber_app_js_1.defineFiberApp)({
+    metadata: {
+        name: "IdentityRegistry",
+        app: "identity",
+        type: "registry",
+        version: "1.0.0",
+        description: "Ecosystem reputation + role-attestation registry; authority-gated writes, dependency reads.",
+        crossReferences: {
+            IdentityAgent: "per-agent reputation source",
+            Governance: "reputation-gated participation",
+            Contracts: "ARBITER-gated dispute settlement",
+            Corporate: "ISSUER / BOARD_MEMBER authority",
+        },
+    },
+    createSchema: {
+        required: ["authority"],
+        properties: {
+            authority: {
+                type: "address",
+                description: "DAG address authorized to write reputation + role attestations (immutable)",
+                immutable: true,
+            },
+        },
+    },
+    stateSchema: {
+        properties: {
+            authority: { type: "address", immutable: true },
+            // { <address>: int } — public reputation, read via signerHasReputation
+            reputations: { type: "object", computed: true },
+            // FLAT per-role attestation maps { <address>: true }, read via signerHasRole
+            arbiters: { type: "object", computed: true },
+            slashers: { type: "object", computed: true },
+            issuers: { type: "object", computed: true },
+            boardMembers: { type: "object", computed: true },
+        },
+    },
+    eventSchemas: {
+        set_reputation: {
+            description: "Authority sets an address's reputation to an absolute score",
+            required: ["subject", "score"],
+            properties: {
+                subject: { type: "address" },
+                score: { type: "integer" },
+            },
+        },
+        adjust_reputation: {
+            description: "Authority adjusts an address's reputation by a signed delta",
+            required: ["subject", "delta"],
+            properties: {
+                subject: { type: "address" },
+                delta: { type: "integer" },
+            },
+        },
+        grant_role: {
+            description: "Authority grants a role attestation (ARBITER|SLASHER|ISSUER|BOARD_MEMBER) to an address",
+            required: ["subject", "role"],
+            properties: {
+                subject: { type: "address" },
+                role: {
+                    type: "string",
+                    enum: ["ARBITER", "SLASHER", "ISSUER", "BOARD_MEMBER"],
+                },
+            },
+        },
+        revoke_role: {
+            description: "Authority revokes a role attestation from an address",
+            required: ["subject", "role"],
+            properties: {
+                subject: { type: "address" },
+                role: {
+                    type: "string",
+                    enum: ["ARBITER", "SLASHER", "ISSUER", "BOARD_MEMBER"],
+                },
+            },
+        },
+    },
+    states: {
+        ACTIVE: {
+            id: "ACTIVE",
+            isFinal: false,
+            metadata: {
+                label: "Active",
+                description: "Registry accepting authority writes",
+                category: "active",
+            },
+        },
+    },
+    initialState: "ACTIVE",
+    transitions: [
+        // ACTIVE → ACTIVE: set_reputation (absolute)
+        {
+            from: "ACTIVE",
+            to: "ACTIVE",
+            eventName: "set_reputation",
+            guard: (0, guards_js_1.signerIsParty)("state.authority"),
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        reputations: {
+                            set: [
+                                { var: "state.reputations" },
+                                { var: "event.subject" },
+                                { var: "event.score" },
+                            ],
+                        },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        // ACTIVE → ACTIVE: adjust_reputation (signed delta; absent subject starts from 0)
+        {
+            from: "ACTIVE",
+            to: "ACTIVE",
+            eventName: "adjust_reputation",
+            guard: (0, guards_js_1.signerIsParty)("state.authority"),
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        reputations: {
+                            set: [
+                                { var: "state.reputations" },
+                                { var: "event.subject" },
+                                {
+                                    "+": [
+                                        {
+                                            get: [
+                                                { var: "state.reputations" },
+                                                { var: "event.subject" },
+                                            ],
+                                        },
+                                        { var: "event.delta" },
+                                    ],
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        // ACTIVE → ACTIVE: grant_role (cascade selects the flat per-role map)
+        {
+            from: "ACTIVE",
+            to: "ACTIVE",
+            eventName: "grant_role",
+            guard: (0, guards_js_1.signerIsParty)("state.authority"),
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        arbiters: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "ARBITER"] },
+                                {
+                                    set: [
+                                        { var: "state.arbiters" },
+                                        { var: "event.subject" },
+                                        true,
+                                    ],
+                                },
+                                { var: "state.arbiters" },
+                            ],
+                        },
+                        slashers: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "SLASHER"] },
+                                {
+                                    set: [
+                                        { var: "state.slashers" },
+                                        { var: "event.subject" },
+                                        true,
+                                    ],
+                                },
+                                { var: "state.slashers" },
+                            ],
+                        },
+                        issuers: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "ISSUER"] },
+                                {
+                                    set: [
+                                        { var: "state.issuers" },
+                                        { var: "event.subject" },
+                                        true,
+                                    ],
+                                },
+                                { var: "state.issuers" },
+                            ],
+                        },
+                        boardMembers: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "BOARD_MEMBER"] },
+                                {
+                                    set: [
+                                        { var: "state.boardMembers" },
+                                        { var: "event.subject" },
+                                        true,
+                                    ],
+                                },
+                                { var: "state.boardMembers" },
+                            ],
+                        },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        // ACTIVE → ACTIVE: revoke_role (cascade unsets from the flat per-role map)
+        {
+            from: "ACTIVE",
+            to: "ACTIVE",
+            eventName: "revoke_role",
+            guard: (0, guards_js_1.signerIsParty)("state.authority"),
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        arbiters: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "ARBITER"] },
+                                { unset: [{ var: "state.arbiters" }, { var: "event.subject" }] },
+                                { var: "state.arbiters" },
+                            ],
+                        },
+                        slashers: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "SLASHER"] },
+                                { unset: [{ var: "state.slashers" }, { var: "event.subject" }] },
+                                { var: "state.slashers" },
+                            ],
+                        },
+                        issuers: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "ISSUER"] },
+                                { unset: [{ var: "state.issuers" }, { var: "event.subject" }] },
+                                { var: "state.issuers" },
+                            ],
+                        },
+                        boardMembers: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "BOARD_MEMBER"] },
+                                {
+                                    unset: [
+                                        { var: "state.boardMembers" },
+                                        { var: "event.subject" },
+                                    ],
+                                },
+                                { var: "state.boardMembers" },
+                            ],
+                        },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+    ],
+});

package/dist/cjs/apps/identity/state-machines/identity-universal.js

@@ -95,7 +95,7 @@ exports.identityUniversalDef = (0, fiber_app_js_1.defineFiberApp)({
             effect: {
                 merge: [
                     { var: "state" },
-                    { status: "ACTIVE", activatedAt: { var: "$timestamp" } },
+                    { status: "ACTIVE", activatedAt: { var: "$ordinal" } },
                 ],
             },
         },
@@ -108,7 +108,7 @@ exports.identityUniversalDef = (0, fiber_app_js_1.defineFiberApp)({
                 merge: [
                     { var: "state" },
                     {
-                        updatedAt: { var: "$timestamp" },
+                        updatedAt: { var: "$ordinal" },
                         metadata: { var: "event.metadata" },
                     },
                 ],
@@ -122,7 +122,7 @@ exports.identityUniversalDef = (0, fiber_app_js_1.defineFiberApp)({
             effect: {
                 merge: [
                     { var: "state" },
-                    { status: "INACTIVE", deactivatedAt: { var: "$timestamp" } },
+                    { status: "INACTIVE", deactivatedAt: { var: "$ordinal" } },
                 ],
             },
         },

package/dist/cjs/apps/identity/state-machines/index.js

@@ -4,10 +4,12 @@
  * Re-exports from TypeScript definition files.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.identityUniversalDef = exports.identityOracleDef = exports.identityAgentDef = void 0;
+exports.identityRegistryDef = exports.identityUniversalDef = exports.identityOracleDef = exports.identityAgentDef = void 0;
 var identity_agent_js_1 = require("./identity-agent.js");
 Object.defineProperty(exports, "identityAgentDef", { enumerable: true, get: function () { return identity_agent_js_1.identityAgentDef; } });
 var identity_oracle_js_1 = require("./identity-oracle.js");
 Object.defineProperty(exports, "identityOracleDef", { enumerable: true, get: function () { return identity_oracle_js_1.identityOracleDef; } });
 var identity_universal_js_1 = require("./identity-universal.js");
 Object.defineProperty(exports, "identityUniversalDef", { enumerable: true, get: function () { return identity_universal_js_1.identityUniversalDef; } });
+var identity_registry_js_1 = require("./identity-registry.js");
+Object.defineProperty(exports, "identityRegistryDef", { enumerable: true, get: function () { return identity_registry_js_1.identityRegistryDef; } });

package/dist/cjs/apps/index.js

@@ -43,18 +43,29 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.corporate = exports.governance = exports.markets = exports.contracts = exports.identity = void 0;
+exports.lending = exports.corporate = exports.governance = exports.markets = exports.contracts = exports.identity = void 0;
 // Re-export as namespaces for organized access
 exports.identity = __importStar(require("./identity/index.js"));
 exports.contracts = __importStar(require("./contracts/index.js"));
 exports.markets = __importStar(require("./markets/index.js"));
 exports.governance = __importStar(require("./governance/index.js"));
 exports.corporate = __importStar(require("./corporate/index.js"));
+exports.lending = __importStar(require("./lending/index.js"));

package/dist/cjs/apps/lending/assets.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * Asset-subsystem integration for the lending family.
+ *
+ * The loan's collateral, principal/debt, and repayment are ASSETS. This module provides
+ * typed payload builders for the OttoChain asset operations and loan-specific helpers that
+ * map the zk-loan lifecycle onto typed asset morphisms.
+ *
+ * Wire shapes mirror the asset-model proposal
+ * (`/home/euler/repos/ottochain/docs/proposals/asset-model.md` §7 — `CreateAssetPolicy`,
+ * `MintAsset`, `ApplyMorphism`, `AuthorizeCompose`; §8 — Governed/ZkVerify-gated morphisms)
+ * and follow the SDK's existing single-key-wrapper convention (the discriminator is the outer
+ * key, e.g. `{ MintAsset: {...} }`), matching `src/ottochain/transaction.ts`
+ * (`createTransitionPayload`, `createScriptPayload`, ...). The asset op-codes are not yet a
+ * merged TypeScript SDK surface; these builders let the lending app construct the proposed
+ * wire format today and sign it with the existing `signTransaction` path.
+ *
+ * Amounts are `Long` on-chain; modeled here as `number` for SDK ergonomics (callers may pass a
+ * string for values beyond 2^53 — the field is serialized verbatim).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenBehaviors = exports.fiberHolder = exports.walletHolder = void 0;
+exports.behaviorBits = behaviorBits;
+exports.createAssetPolicyPayload = createAssetPolicyPayload;
+exports.createMintAssetPayload = createMintAssetPayload;
+exports.createApplyMorphismPayload = createApplyMorphismPayload;
+exports.createAuthorizeComposePayload = createAuthorizeComposePayload;
+exports.collateralPolicy = collateralPolicy;
+exports.debtPolicy = debtPolicy;
+exports.lockCollateralOp = lockCollateralOp;
+exports.mintPrincipalOp = mintPrincipalOp;
+exports.repayBurnOp = repayBurnOp;
+exports.settleCollateralOp = settleCollateralOp;
+/** Helpers for the two-variant holder. */
+const walletHolder = (address) => ({ Wallet: { address } });
+exports.walletHolder = walletHolder;
+const fiberHolder = (fiberId) => ({ Fiber: { fiberId } });
+exports.fiberHolder = fiberHolder;
+/** Pack a {@link TokenBehavior} to its 5-bit integer (T=16 S=8 C=4 E=2 G=1). */
+function behaviorBits(b) {
+    return ((b.transferable ? 16 : 0) |
+        (b.splittable ? 8 : 0) |
+        (b.combinable ? 4 : 0) |
+        (b.expirable ? 2 : 0) |
+        (b.governable ? 1 : 0));
+}
+/** Common behavior presets (asset-model.md §2). */
+exports.TokenBehaviors = {
+    /** Non-transferable, non-divisible (bits 0). */
+    Soulbound: { transferable: false, splittable: false, combinable: false, expirable: false, governable: false },
+    /** Transferable only (bits 16). */
+    NFT: { transferable: true, splittable: false, combinable: false, expirable: false, governable: false },
+    /** Transferable + splittable + combinable (bits 28 = TSC). */
+    Fungible: { transferable: true, splittable: true, combinable: true, expirable: false, governable: false },
+    /** Fungible + governable (bits 29 = TSCG) — the default for a gated debt token. */
+    GovernedFungible: { transferable: true, splittable: true, combinable: true, expirable: false, governable: true },
+};
+/** Publish an asset policy package version. asset-model.md §7. */
+function createAssetPolicyPayload(params) {
+    return {
+        CreateAssetPolicy: {
+            name: params.name,
+            version: params.version,
+            behavior: params.behavior,
+            supply: params.supply,
+            morphisms: params.morphisms,
+            stateShape: params.stateShape,
+            ...(params.metadata ? { metadata: params.metadata } : {}),
+        },
+    };
+}
+/**
+ * Mint an asset instance. asset-model.md §7. When the policy's `mintPolicy` is a
+ * `groth16_verify` guard (proof-gated mint), pass the eligibility `witness`.
+ */
+function createMintAssetPayload(params) {
+    return {
+        MintAsset: {
+            assetId: params.assetId,
+            policyRef: params.policyRef,
+            holder: params.holder,
+            amount: params.amount,
+            ...(params.expiresAt !== undefined ? { expiresAt: params.expiresAt } : {}),
+            ...(params.witness ? { witness: params.witness } : {}),
+        },
+    };
+}
+/**
+ * Apply a typed morphism (Transfer / Burn / Compose / ...). asset-model.md §7.
+ * Transfer = `{ kind: "Transfer", recipient }`; Burn (repay) = `{ kind: "Burn" }`.
+ */
+function createApplyMorphismPayload(params) {
+    return {
+        ApplyMorphism: {
+            assetId: params.assetId,
+            kind: params.kind,
+            targetSequenceNumber: params.targetSequenceNumber,
+            ...(params.recipient ? { recipient: params.recipient } : {}),
+            ...(params.otherAssets ? { otherAssets: params.otherAssets } : {}),
+            ...(params.compositeId ? { compositeId: params.compositeId } : {}),
+            ...(params.shardIds ? { shardIds: params.shardIds } : {}),
+            ...(params.nonce !== undefined ? { nonce: params.nonce } : {}),
+            ...(params.witness ? { witness: params.witness } : {}),
+        },
+    };
+}
+/** Commit half of a two-party compose. asset-model.md §7/§8. */
+function createAuthorizeComposePayload(params) {
+    return {
+        AuthorizeCompose: {
+            assetId: params.assetId,
+            partnerPolicy: params.partnerPolicy,
+            nonce: params.nonce,
+            expiresAt: params.expiresAt,
+            targetSequenceNumber: params.targetSequenceNumber,
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Loan-specific asset policy builders
+// ---------------------------------------------------------------------------
+/**
+ * The collateral vault policy: an NFT-like custodial holding (no fungible split) whose
+ * `Transfer` morphism is Governed — the loan/escrow fiber is the authorization. Locking is
+ * a custody Transfer into `AssetHolder.Fiber(escrow)`; release/liquidation is a Transfer out
+ * driven by the loan fiber's REPAID / LIQUIDATED transition (`_transferAsset`).
+ */
+function collateralPolicy(name = "collateral-vault-v1.asset", version = "1.0.0") {
+    return {
+        name,
+        version,
+        behavior: { transferable: true, splittable: false, combinable: false, expirable: false, governable: true },
+        supply: { maxSupply: null, mintPolicy: null, burnPolicy: null, decimals: 0 },
+        morphisms: {
+            Transfer: { visibility: "Governed" },
+            Burn: { visibility: "Disabled" },
+            Compose: { visibility: "Disabled" },
+        },
+        stateShape: {},
+        metadata: { family: "lending", role: "collateral" },
+    };
+}
+/**
+ * The loan-debt / principal policy: a governed fungible whose `mintPolicy` is the
+ * proof-gated origination guard — the principal is mintable to the borrower only when the
+ * eligibility proof verifies. Repayment is a `Burn` governed by `burnPolicy`.
+ *
+ * @param mintGuard the origination guard (see `buildOriginationGuard`) — a `groth16_verify`
+ *   expression bound to the pinned public lending rule.
+ */
+function debtPolicy(mintGuard, name = "loan-debt-v1.asset", version = "1.0.0") {
+    return {
+        name,
+        version,
+        behavior: exports.TokenBehaviors.GovernedFungible,
+        supply: {
+            maxSupply: null,
+            // Proof-gated mint: principal is minted only if the eligibility proof verifies.
+            mintPolicy: mintGuard,
+            // Repayment burns the debt; only the holder (borrower) may burn theirs. The asset context has
+            // no `event` key — bind to the verified `signers` (chain-derived from the op's proofs).
+            burnPolicy: { in: [{ var: "holder.Wallet.address" }, { var: "signers" }] },
+            decimals: 2,
+        },
+        morphisms: {
+            Transfer: { visibility: "Public" },
+            Burn: { visibility: "Public" },
+        },
+        stateShape: {},
+        metadata: { family: "lending", role: "debt" },
+    };
+}
+// ---------------------------------------------------------------------------
+// Loan lifecycle → asset morphism drivers
+// ---------------------------------------------------------------------------
+/**
+ * lock_collateral: custody Transfer of the pledged collateral into the loan escrow fiber.
+ * (asset-model.md §10 — locking is a custody transfer to `AssetHolder.Fiber`, there is no
+ * `Lock` morphism.)
+ */
+function lockCollateralOp(args) {
+    return createApplyMorphismPayload({
+        assetId: args.collateralAssetId,
+        kind: "Transfer",
+        recipient: (0, exports.fiberHolder)(args.escrowFiberId),
+        targetSequenceNumber: args.targetSequenceNumber,
+    });
+}
+/**
+ * originate: Mint the loan principal/debt to the borrower. The policy's `mintPolicy`
+ * (the origination guard) reads the eligibility `witness` ({publicValues, proof}).
+ */
+function mintPrincipalOp(args) {
+    return createMintAssetPayload({
+        assetId: args.debtAssetId,
+        policyRef: args.debtPolicyRef,
+        holder: (0, exports.walletHolder)(args.borrower),
+        amount: args.principalAmount,
+        witness: args.witness,
+    });
+}
+/** repay: Burn the borrower's debt token (the principal is repaid). */
+function repayBurnOp(args) {
+    return createApplyMorphismPayload({
+        assetId: args.debtAssetId,
+        kind: "Burn",
+        targetSequenceNumber: args.targetSequenceNumber,
+    });
+}
+/**
+ * release / liquidate: Transfer the escrowed collateral out of the escrow fiber to a
+ * recipient (the borrower on REPAID, the lender on LIQUIDATED). On-chain this is emitted by
+ * the loan fiber's transition via `_transferAsset`; this builder produces the equivalent
+ * explicit `ApplyMorphism(Transfer)` for off-fiber/manual settlement.
+ */
+function settleCollateralOp(args) {
+    return createApplyMorphismPayload({
+        assetId: args.collateralAssetId,
+        kind: "Transfer",
+        recipient: (0, exports.walletHolder)(args.recipient),
+        targetSequenceNumber: args.targetSequenceNumber,
+    });
+}