@ottochain/sdk 2.3.0 → 2.5.0

package/dist/types/apps/identity/state-machines/identity-registry.d.ts

@@ -0,0 +1,379 @@
+/**
+ * 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).
+ */
+export declare const identityRegistryDef: {
+    metadata: {
+        name: string;
+        app: string;
+        type: string;
+        version: string;
+        description: string;
+        crossReferences: {
+            IdentityAgent: string;
+            Governance: string;
+            Contracts: string;
+            Corporate: string;
+        };
+    };
+    createSchema: {
+        required: readonly ["authority"];
+        properties: {
+            authority: {
+                type: "address";
+                description: string;
+                immutable: true;
+            };
+        };
+    };
+    stateSchema: {
+        properties: {
+            authority: {
+                type: "address";
+                immutable: true;
+            };
+            reputations: {
+                type: "object";
+                computed: true;
+            };
+            arbiters: {
+                type: "object";
+                computed: true;
+            };
+            slashers: {
+                type: "object";
+                computed: true;
+            };
+            issuers: {
+                type: "object";
+                computed: true;
+            };
+            boardMembers: {
+                type: "object";
+                computed: true;
+            };
+        };
+    };
+    eventSchemas: {
+        set_reputation: {
+            description: string;
+            required: readonly ["subject", "score"];
+            properties: {
+                subject: {
+                    type: "address";
+                };
+                score: {
+                    type: "integer";
+                };
+            };
+        };
+        adjust_reputation: {
+            description: string;
+            required: readonly ["subject", "delta"];
+            properties: {
+                subject: {
+                    type: "address";
+                };
+                delta: {
+                    type: "integer";
+                };
+            };
+        };
+        grant_role: {
+            description: string;
+            required: readonly ["subject", "role"];
+            properties: {
+                subject: {
+                    type: "address";
+                };
+                role: {
+                    type: "string";
+                    enum: readonly ["ARBITER", "SLASHER", "ISSUER", "BOARD_MEMBER"];
+                };
+            };
+        };
+        revoke_role: {
+            description: string;
+            required: readonly ["subject", "role"];
+            properties: {
+                subject: {
+                    type: "address";
+                };
+                role: {
+                    type: "string";
+                    enum: readonly ["ARBITER", "SLASHER", "ISSUER", "BOARD_MEMBER"];
+                };
+            };
+        };
+    };
+    states: {
+        ACTIVE: {
+            id: string;
+            isFinal: false;
+            metadata: {
+                label: string;
+                description: string;
+                category: "active";
+            };
+        };
+    };
+    initialState: "ACTIVE";
+    transitions: ({
+        from: "ACTIVE";
+        to: "ACTIVE";
+        eventName: "set_reputation";
+        guard: import("../../../schema/guards.js").GuardRule;
+        effect: {
+            merge: ({
+                var: string;
+                reputations?: undefined;
+            } | {
+                reputations: {
+                    set: {
+                        var: string;
+                    }[];
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "ACTIVE";
+        to: "ACTIVE";
+        eventName: "adjust_reputation";
+        guard: import("../../../schema/guards.js").GuardRule;
+        effect: {
+            merge: ({
+                var: string;
+                reputations?: undefined;
+            } | {
+                reputations: {
+                    set: ({
+                        var: string;
+                        '+'?: undefined;
+                    } | {
+                        '+': ({
+                            get: {
+                                var: string;
+                            }[];
+                            var?: undefined;
+                        } | {
+                            var: string;
+                            get?: undefined;
+                        })[];
+                        var?: undefined;
+                    })[];
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "ACTIVE";
+        to: "ACTIVE";
+        eventName: "grant_role";
+        guard: import("../../../schema/guards.js").GuardRule;
+        effect: {
+            merge: ({
+                var: string;
+                arbiters?: undefined;
+                slashers?: undefined;
+                issuers?: undefined;
+                boardMembers?: undefined;
+            } | {
+                arbiters: {
+                    if: ({
+                        '==': (string | {
+                            var: string;
+                        })[];
+                        set?: undefined;
+                        var?: undefined;
+                    } | {
+                        set: (boolean | {
+                            var: string;
+                        })[];
+                        '=='?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        '=='?: undefined;
+                        set?: undefined;
+                    })[];
+                };
+                slashers: {
+                    if: ({
+                        '==': (string | {
+                            var: string;
+                        })[];
+                        set?: undefined;
+                        var?: undefined;
+                    } | {
+                        set: (boolean | {
+                            var: string;
+                        })[];
+                        '=='?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        '=='?: undefined;
+                        set?: undefined;
+                    })[];
+                };
+                issuers: {
+                    if: ({
+                        '==': (string | {
+                            var: string;
+                        })[];
+                        set?: undefined;
+                        var?: undefined;
+                    } | {
+                        set: (boolean | {
+                            var: string;
+                        })[];
+                        '=='?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        '=='?: undefined;
+                        set?: undefined;
+                    })[];
+                };
+                boardMembers: {
+                    if: ({
+                        '==': (string | {
+                            var: string;
+                        })[];
+                        set?: undefined;
+                        var?: undefined;
+                    } | {
+                        set: (boolean | {
+                            var: string;
+                        })[];
+                        '=='?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        '=='?: undefined;
+                        set?: undefined;
+                    })[];
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "ACTIVE";
+        to: "ACTIVE";
+        eventName: "revoke_role";
+        guard: import("../../../schema/guards.js").GuardRule;
+        effect: {
+            merge: ({
+                var: string;
+                arbiters?: undefined;
+                slashers?: undefined;
+                issuers?: undefined;
+                boardMembers?: undefined;
+            } | {
+                arbiters: {
+                    if: ({
+                        '==': (string | {
+                            var: string;
+                        })[];
+                        unset?: undefined;
+                        var?: undefined;
+                    } | {
+                        unset: {
+                            var: string;
+                        }[];
+                        '=='?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        '=='?: undefined;
+                        unset?: undefined;
+                    })[];
+                };
+                slashers: {
+                    if: ({
+                        '==': (string | {
+                            var: string;
+                        })[];
+                        unset?: undefined;
+                        var?: undefined;
+                    } | {
+                        unset: {
+                            var: string;
+                        }[];
+                        '=='?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        '=='?: undefined;
+                        unset?: undefined;
+                    })[];
+                };
+                issuers: {
+                    if: ({
+                        '==': (string | {
+                            var: string;
+                        })[];
+                        unset?: undefined;
+                        var?: undefined;
+                    } | {
+                        unset: {
+                            var: string;
+                        }[];
+                        '=='?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        '=='?: undefined;
+                        unset?: undefined;
+                    })[];
+                };
+                boardMembers: {
+                    if: ({
+                        '==': (string | {
+                            var: string;
+                        })[];
+                        unset?: undefined;
+                        var?: undefined;
+                    } | {
+                        unset: {
+                            var: string;
+                        }[];
+                        '=='?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        '=='?: undefined;
+                        unset?: undefined;
+                    })[];
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    })[];
+};
+export type RegistryState = keyof typeof identityRegistryDef.states;
+export type RegistryEvent = (typeof identityRegistryDef.transitions)[number]['eventName'];

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

@@ -103,7 +103,7 @@ export declare const identityUniversalDef: {
         to: "ACTIVE";
         eventName: "activate";
         guard: {
-            "==": number[];
+            '==': number[];
         };
         effect: {
             merge: ({
@@ -123,7 +123,7 @@ export declare const identityUniversalDef: {
         to: "ACTIVE";
         eventName: "update";
         guard: {
-            "==": number[];
+            '==': number[];
         };
         effect: {
             merge: ({
@@ -145,7 +145,7 @@ export declare const identityUniversalDef: {
         to: "INACTIVE";
         eventName: "deactivate";
         guard: {
-            "==": number[];
+            '==': number[];
         };
         effect: {
             merge: ({
@@ -163,4 +163,4 @@ export declare const identityUniversalDef: {
     })[];
 };
 export type UniversalIdentityState = keyof typeof identityUniversalDef.states;
-export type UniversalIdentityEvent = (typeof identityUniversalDef.transitions)[number]["eventName"];
+export type UniversalIdentityEvent = (typeof identityUniversalDef.transitions)[number]['eventName'];

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

@@ -5,3 +5,4 @@
 export { identityAgentDef } from './identity-agent.js';
 export { identityOracleDef } from './identity-oracle.js';
 export { identityUniversalDef } from './identity-universal.js';
+export { identityRegistryDef } from './identity-registry.js';

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

@@ -26,8 +26,12 @@
  *
  * @packageDocumentation
  */
-export * as identity from "./identity/index.js";
-export * as contracts from "./contracts/index.js";
-export * as markets from "./markets/index.js";
-export * as governance from "./governance/index.js";
-export * as corporate from "./corporate/index.js";
+export * as identity from './identity/index.js';
+export * as contracts from './contracts/index.js';
+export * as markets from './markets/index.js';
+export * as governance from './governance/index.js';
+export * as corporate from './corporate/index.js';
+export * as lending from './lending/index.js';
+export * as compute from './compute/index.js';
+export * as stakedPool from './staked-pool/index.js';
+export * as privacy from './privacy/index.js';

package/dist/types/apps/lending/assets.d.ts

@@ -0,0 +1,258 @@
+/**
+ * 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).
+ */
+/** A holder of an asset: a wallet address, or a custody fiber (the escrow). */
+export type AssetHolder = {
+    Wallet: {
+        address: string;
+    };
+} | {
+    Fiber: {
+        fiberId: string;
+    };
+};
+/** Helpers for the two-variant holder. */
+export declare const walletHolder: (address: string) => AssetHolder;
+export declare const fiberHolder: (fiberId: string) => AssetHolder;
+/** 5-bit token behavior lattice (T/S/C ascending, E/G descending). asset-model.md §2. */
+export interface TokenBehavior {
+    transferable: boolean;
+    splittable: boolean;
+    combinable: boolean;
+    expirable: boolean;
+    governable: boolean;
+}
+/** Pack a {@link TokenBehavior} to its 5-bit integer (T=16 S=8 C=4 E=2 G=1). */
+export declare function behaviorBits(b: TokenBehavior): number;
+/** Common behavior presets (asset-model.md §2). */
+export declare const TokenBehaviors: {
+    /** Non-transferable, non-divisible (bits 0). */
+    readonly Soulbound: TokenBehavior;
+    /** Transferable only (bits 16). */
+    readonly NFT: TokenBehavior;
+    /** Transferable + splittable + combinable (bits 28 = TSC). */
+    readonly Fungible: TokenBehavior;
+    /** Fungible + governable (bits 29 = TSCG) — the default for a gated debt token. */
+    readonly GovernedFungible: TokenBehavior;
+};
+/** A JSON-Logic expression (guard/policy). */
+export type JsonLogicRule = Record<string, unknown>;
+/** Supply policy: cap, mint/burn JSON-Logic guards, decimals. asset-model.md §3. */
+export interface SupplyPolicy {
+    /** Hard cap; null = uncapped. */
+    maxSupply?: number | string | null;
+    /** Mint guard (JSON-Logic); null = minting closed after genesis. */
+    mintPolicy?: JsonLogicRule | null;
+    /** Burn guard (JSON-Logic); null = no burning. */
+    burnPolicy?: JsonLogicRule | null;
+    /** Fungible decimals; null/0 for NFTs. */
+    decimals?: number | null;
+}
+/** Morphism kinds. asset-model.md §4. */
+export type MorphismKind = 'Transfer' | 'Burn' | 'Fractionalize' | 'Compose' | 'Decompose' | 'Wrap' | 'Stake';
+/** Morphism visibility — Governed carries a JSON-Logic guard. asset-model.md §8. */
+export type MorphismVisibility = 'Public' | 'Governed' | 'Disabled';
+/** Per-kind morphism spec on a policy version. asset-model.md §7. */
+export interface MorphismSpec {
+    visibility: MorphismVisibility;
+    /** Counter-party policy allowlist; omit for any. */
+    allowedPolicies?: string[];
+    /** Counter-party behavior-bitmask allowlist; omit for any. */
+    allowedTypes?: number[];
+    /** JSON-Logic guard (Governed only). */
+    guard?: JsonLogicRule;
+}
+/** A version requirement for resolving a policy. mirrors SDK `VersionReq`. */
+export type VersionReq = {
+    Exact: {
+        version: string;
+    };
+} | {
+    Caret: {
+        version: string;
+    };
+} | {
+    Tilde: {
+        version: string;
+    };
+} | {
+    Latest: Record<string, never>;
+} | {
+    PinnedHash: {
+        hash: string;
+    };
+};
+/** A policy reference `(name, versionReq)`. mirrors SDK `SchemaRef`. */
+export interface PolicyRef {
+    name: string;
+    version: VersionReq;
+}
+export interface CreateAssetPolicyParams {
+    /** `.asset` registry name, e.g. "collateral-vault-v1.asset". */
+    name: string;
+    version: string;
+    behavior: TokenBehavior;
+    supply: SupplyPolicy;
+    morphisms: Partial<Record<MorphismKind, MorphismSpec>>;
+    /** The asset record's state shape (proto message shape); free-form here. */
+    stateShape: Record<string, unknown>;
+    metadata?: Record<string, string>;
+}
+export interface CreateAssetPolicyMessage {
+    CreateAssetPolicy: {
+        name: string;
+        version: string;
+        behavior: TokenBehavior;
+        supply: SupplyPolicy;
+        morphisms: Partial<Record<MorphismKind, MorphismSpec>>;
+        stateShape: Record<string, unknown>;
+        metadata?: Record<string, string>;
+    };
+}
+/** Publish an asset policy package version. asset-model.md §7. */
+export declare function createAssetPolicyPayload(params: CreateAssetPolicyParams): CreateAssetPolicyMessage;
+export interface MintAssetParams {
+    /** The new asset instance id (UUID). */
+    assetId: string;
+    policyRef: PolicyRef;
+    holder: AssetHolder;
+    amount: number | string;
+    expiresAt?: number;
+    /** Witness the policy's `mintPolicy` guard reads (e.g. a Groth16 eligibility proof). */
+    witness?: Record<string, unknown>;
+}
+export interface MintAssetMessage {
+    MintAsset: {
+        assetId: string;
+        policyRef: PolicyRef;
+        holder: AssetHolder;
+        amount: number | string;
+        expiresAt?: number;
+        witness?: Record<string, unknown>;
+    };
+}
+/**
+ * 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`.
+ */
+export declare function createMintAssetPayload(params: MintAssetParams): MintAssetMessage;
+export interface ApplyMorphismParams {
+    assetId: string;
+    kind: MorphismKind;
+    targetSequenceNumber: number;
+    recipient?: AssetHolder;
+    otherAssets?: string[];
+    compositeId?: string;
+    shardIds?: string[];
+    nonce?: number;
+    /** Witness a Governed morphism's `guard` reads. */
+    witness?: Record<string, unknown>;
+}
+export interface ApplyMorphismMessage {
+    ApplyMorphism: {
+        assetId: string;
+        kind: MorphismKind;
+        targetSequenceNumber: number;
+        recipient?: AssetHolder;
+        otherAssets?: string[];
+        compositeId?: string;
+        shardIds?: string[];
+        nonce?: number;
+        witness?: Record<string, unknown>;
+    };
+}
+/**
+ * Apply a typed morphism (Transfer / Burn / Compose / ...). asset-model.md §7.
+ * Transfer = `{ kind: "Transfer", recipient }`; Burn (repay) = `{ kind: "Burn" }`.
+ */
+export declare function createApplyMorphismPayload(params: ApplyMorphismParams): ApplyMorphismMessage;
+export interface AuthorizeComposeParams {
+    assetId: string;
+    partnerPolicy: string;
+    nonce: number;
+    expiresAt: number;
+    targetSequenceNumber: number;
+}
+export interface AuthorizeComposeMessage {
+    AuthorizeCompose: {
+        assetId: string;
+        partnerPolicy: string;
+        nonce: number;
+        expiresAt: number;
+        targetSequenceNumber: number;
+    };
+}
+/** Commit half of a two-party compose. asset-model.md §7/§8. */
+export declare function createAuthorizeComposePayload(params: AuthorizeComposeParams): AuthorizeComposeMessage;
+/**
+ * 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`).
+ */
+export declare function collateralPolicy(name?: string, version?: string): CreateAssetPolicyParams;
+/**
+ * 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.
+ */
+export declare function debtPolicy(mintGuard: JsonLogicRule, name?: string, version?: string): CreateAssetPolicyParams;
+/**
+ * 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.)
+ */
+export declare function lockCollateralOp(args: {
+    collateralAssetId: string;
+    escrowFiberId: string;
+    targetSequenceNumber: number;
+}): ApplyMorphismMessage;
+/**
+ * originate: Mint the loan principal/debt to the borrower. The policy's `mintPolicy`
+ * (the origination guard) reads the eligibility `witness` ({publicValues, proof}).
+ */
+export declare function mintPrincipalOp(args: {
+    debtAssetId: string;
+    debtPolicyRef: PolicyRef;
+    borrower: string;
+    principalAmount: number | string;
+    witness: {
+        publicValues: string;
+        proof: string;
+    };
+}): MintAssetMessage;
+/** repay: Burn the borrower's debt token (the principal is repaid). */
+export declare function repayBurnOp(args: {
+    debtAssetId: string;
+    targetSequenceNumber: number;
+}): ApplyMorphismMessage;
+/**
+ * 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.
+ */
+export declare function settleCollateralOp(args: {
+    collateralAssetId: string;
+    recipient: string;
+    targetSequenceNumber: number;
+}): ApplyMorphismMessage;