@ottochain/sdk 2.3.0 → 2.5.0

package/dist/esm/apps/staked-pool/base.js

@@ -0,0 +1,493 @@
+/**
+ * Staked-pool BASE factory — a reusable staked-epoch-pool lifecycle skeleton.
+ *
+ * Lifecycle: FORMING → COLLECTING → SETTLED → COLLECTING (reset) … → CLOSED.
+ *   FORMING    (initial) — accepting stake/join; registry bound; not yet running epochs.
+ *   COLLECTING           — epoch open; participants submit datapoints/votes.
+ *   SETTLED              — result published; entitlement ledger credited; result readable cross-fiber.
+ *   CLOSED     (final)   — wound down; stakes + unclaimed rewards still withdrawable/claimable.
+ *
+ * The base composes EXISTING SDK primitives only:
+ *   - `signerIsParty` (authority gate), `actorIsSigner`/`actorHasEntry` (effect-key↔signer coupling),
+ *     `signerHasReputationVia` (the #24 dynamic-dep reputation-gated join), `actorNotInArray` (array dedup),
+ *     `depInState` (cross-fiber consumer read — used by the consumer, not the pool itself) — `src/schema/guards.ts`.
+ *   - `addDependency` (#24 bind), `transferAsset` (whole-instance custody move) — `src/schema/effects.ts`.
+ *
+ * Value model (design §2.1, §4 — resolved):
+ *   - Submissions are an APPEND-ONLY ARRAY of `{ addr, value }` records (no map-keyed-by-address, because
+ *     there is no `(array,int)` element-index op). Append is `merge[state.submissions, [record]]` — verified.
+ *   - finalize emits ZERO asset transfers: it publishes `result` and records the in-consensus address set
+ *     into `inConsensus` (the entitlement ledger). No reward map-fold (a map-valued `reduce` accumulator is
+ *     rejected by the VM — `isPrimitive` guard in `opReduce`); entitlement is membership in `inConsensus`.
+ *   - reward = PER-CLAIM on a shared fungible: `claim_reward` moves ONE whole reward instance the pool holds
+ *     to a verified, in-consensus, not-yet-claimed signer, and marks `claimed[addr] = true`. ≤1 transfer.
+ *   - withdraw_stake / hard-slash each emit exactly ONE whole `_transferAsset` ⇒ never the 32-cap.
+ *
+ * Multi-`from` arms are SPLIT into one transition per source state (chain `from` is a single string):
+ *   stake_and_join ×2, claim_reward ×2, withdraw_stake ×2, close ×3.
+ */
+import { defineFiberApp } from '../../schema/fiber-app.js';
+import { signerIsParty, actorIsSigner, signerHasReputationVia, actorNotInArray } from '../../schema/guards.js';
+import { addDependency, transferAsset, toWallet } from '../../schema/effects.js';
+// ---------------------------------------------------------------------------
+// Shared guard fragments (composed from the canonical builders)
+// ---------------------------------------------------------------------------
+/** event.agent is among the verified signers (proofs[].address). */
+const isSigner = () => actorIsSigner('event.agent');
+/** event.agent is a verified signer AND a key in the flat membership map `state.participants`. */
+const isJoinedParticipant = () => ({
+    and: [isSigner(), { has: [{ var: 'state.participants' }, { var: 'event.agent' }] }],
+});
+/** The submit window is still open: $ordinal <= epochStartedAt + epochLength. */
+const withinEpochWindow = () => ({
+    '<=': [{ var: '$ordinal' }, { '+': [{ var: 'state.epochStartedAt' }, { var: 'state.epochLength' }] }],
+});
+/**
+ * H5 stake-reality: the pool actually holds `event.stakeAssetId` with `amount >= state.stakeAmount`.
+ * `heldAssets` is injected keyed by assetId and is BY CONSTRUCTION only the assets this fiber holds.
+ */
+const poolHoldsStake = () => ({
+    and: [
+        { has: [{ var: 'heldAssets' }, { var: 'event.stakeAssetId' }] },
+        {
+            '>=': [
+                {
+                    get: [{ get: [{ var: 'heldAssets' }, { var: 'event.stakeAssetId' }] }, 'amount'],
+                },
+                { var: 'state.stakeAmount' },
+            ],
+        },
+    ],
+});
+// ---------------------------------------------------------------------------
+// Base transition bodies (parameterized by `from`/`to` for the split arms)
+// ---------------------------------------------------------------------------
+const dep0 = { dependencies: [] };
+/** bind_registry FORMING→FORMING — #24 genesis bind site; MUST precede all reputation-gated joins. */
+function bindRegistryArm() {
+    return {
+        from: 'FORMING',
+        to: 'FORMING',
+        eventName: 'bind_registry',
+        guard: signerIsParty('state.authority'),
+        // Only effect: bind the identity registry so machines.<registryId> is readable NEXT transition (#24).
+        effect: {
+            merge: [{ var: 'state' }, { ...addDependency({ var: 'state.registryId' }) }],
+        },
+        ...dep0,
+    };
+}
+/**
+ * stake_and_join {from}→{from} — reputation-gated join + stake-custody VERIFICATION (H5).
+ * actorIsSigner is load-bearing: it pins the written participant key to the verified signer (anti-S1).
+ */
+function stakeAndJoinArm(state) {
+    return {
+        from: state,
+        to: state,
+        eventName: 'stake_and_join',
+        guard: {
+            and: [
+                isSigner(), // anti-S1: the written key == verified signer
+                { '===': [{ var: 'event.stakeAmount' }, { var: 'state.stakeAmount' }] },
+                {
+                    '!': [{ has: [{ var: 'state.participants' }, { var: 'event.agent' }] }],
+                }, // dedup
+                poolHoldsStake(), // H5
+                signerHasReputationVia('state.registryId', 'state.minReputation'), // #24 reputation gate
+            ],
+        },
+        effect: {
+            merge: [
+                { var: 'state' },
+                {
+                    participants: {
+                        set: [{ var: 'state.participants' }, { var: 'event.agent' }, true],
+                    },
+                    stakes: {
+                        set: [{ var: 'state.stakes' }, { var: 'event.agent' }, { var: 'event.stakeAmount' }],
+                    },
+                    stakeAssetIds: {
+                        set: [{ var: 'state.stakeAssetIds' }, { var: 'event.agent' }, { var: 'event.stakeAssetId' }],
+                    },
+                },
+            ],
+        },
+        ...dep0,
+    };
+}
+/** open_first_epoch FORMING→COLLECTING — authority opens epoch 1. */
+function openFirstEpochArm() {
+    return {
+        from: 'FORMING',
+        to: 'COLLECTING',
+        eventName: 'open_first_epoch',
+        guard: signerIsParty('state.authority'),
+        effect: {
+            merge: [
+                { var: 'state' },
+                {
+                    status: 'COLLECTING',
+                    epoch: 1,
+                    epochStartedAt: { var: '$ordinal' },
+                    submissions: [],
+                },
+            ],
+        },
+        ...dep0,
+    };
+}
+/** reset_epoch SETTLED→COLLECTING — authority advances the epoch; clears submissions + inConsensus + claimed. */
+function resetEpochArm() {
+    return {
+        from: 'SETTLED',
+        to: 'COLLECTING',
+        eventName: 'reset_epoch',
+        guard: signerIsParty('state.authority'),
+        effect: {
+            merge: [
+                { var: 'state' },
+                {
+                    status: 'COLLECTING',
+                    epoch: { '+': [{ var: 'state.epoch' }, 1] },
+                    epochStartedAt: { var: '$ordinal' },
+                    submissions: [],
+                    inConsensus: [],
+                    claimed: {},
+                },
+            ],
+        },
+        ...dep0,
+    };
+}
+/**
+ * submit COLLECTING→COLLECTING — append one `{addr,value}` datapoint. OVERRIDABLE per specialization.
+ * Guard = joined participant (signer-pinned) AND within window AND not-yet-submitted-this-epoch (array dedup).
+ */
+export function defaultSubmitArm() {
+    return {
+        from: 'COLLECTING',
+        to: 'COLLECTING',
+        eventName: 'submit',
+        guard: {
+            and: [isJoinedParticipant(), withinEpochWindow(), actorNotInArray('state.submissions', 'addr', 'event.agent')],
+        },
+        // Array append via merge (verified: merge[arr, [record]] concatenates).
+        effect: {
+            merge: [
+                { var: 'state' },
+                {
+                    submissions: {
+                        merge: [{ var: 'state.submissions' }, [{ addr: { var: 'event.agent' }, value: { var: 'event.value' } }]],
+                    },
+                },
+            ],
+        },
+        ...dep0,
+    };
+}
+/**
+ * claim_reward {from}→{from} — pull ONE whole reward instance for an in-consensus, not-yet-claimed entitlement.
+ * Reward = per-claim on a shared fungible: the pool transfers one held reward instance to the claimant.
+ */
+function claimRewardArm(state) {
+    return {
+        from: state,
+        to: state,
+        eventName: 'claim_reward',
+        guard: {
+            and: [
+                isSigner(), // anti-S1: recipient/claimed key == verified signer
+                {
+                    some: [{ var: 'state.inConsensus' }, { '===': [{ var: '' }, { var: 'event.agent' }] }],
+                }, // entitled
+                { '!': [{ has: [{ var: 'state.claimed' }, { var: 'event.agent' }] }] }, // not already claimed
+                { has: [{ var: 'heldAssets' }, { var: 'event.rewardAssetId' }] }, // pool holds the named instance
+            ],
+        },
+        effect: {
+            merge: [
+                { var: 'state' },
+                {
+                    claimed: {
+                        set: [{ var: 'state.claimed' }, { var: 'event.agent' }, true],
+                    },
+                    ...transferAsset([
+                        {
+                            assetId: { var: 'event.rewardAssetId' },
+                            recipient: toWallet({ var: 'event.agent' }),
+                        },
+                    ]),
+                },
+            ],
+        },
+        ...dep0,
+    };
+}
+/**
+ * withdraw_stake {from}→{from} — participant reclaims their staked instance (ONE whole transfer).
+ * H4: the `_transferAsset.assetId` read of `stakeAssetIds[agent]` and the sibling `unset` BOTH see the
+ * PRE-MERGE state (verified) — so reading-then-unsetting in one merge is correct, not a strand.
+ */
+function withdrawStakeArm(state) {
+    return {
+        from: state,
+        to: state,
+        eventName: 'withdraw_stake',
+        guard: {
+            and: [isSigner(), { has: [{ var: 'state.stakeAssetIds' }, { var: 'event.agent' }] }],
+        },
+        effect: {
+            merge: [
+                { var: 'state' },
+                {
+                    stakes: { set: [{ var: 'state.stakes' }, { var: 'event.agent' }, 0] },
+                    stakeAssetIds: {
+                        unset: [{ var: 'state.stakeAssetIds' }, { var: 'event.agent' }],
+                    },
+                    ...transferAsset([
+                        {
+                            assetId: {
+                                get: [{ var: 'state.stakeAssetIds' }, { var: 'event.agent' }],
+                            }, // pre-merge read (H4)
+                            recipient: toWallet({ var: 'event.agent' }),
+                        },
+                    ]),
+                },
+            ],
+        },
+        ...dep0,
+    };
+}
+/** close {from}→CLOSED — authority winds the pool down. Stakes/rewards remain withdrawable/claimable. */
+function closeArm(state) {
+    return {
+        from: state,
+        to: 'CLOSED',
+        eventName: 'close',
+        guard: signerIsParty('state.authority'),
+        effect: {
+            merge: [{ var: 'state' }, { status: 'CLOSED', closedAt: { var: '$ordinal' } }],
+        },
+        ...dep0,
+    };
+}
+// ---------------------------------------------------------------------------
+// Shared schemas
+// ---------------------------------------------------------------------------
+const baseCreateSchema = {
+    required: [
+        'authority',
+        'registryId',
+        'minReputation',
+        'stakePolicy',
+        'stakeAmount',
+        'quorum',
+        'epochLength',
+        'outlierBound',
+        'rewardPerEpoch',
+    ],
+    properties: {
+        authority: {
+            type: 'address',
+            description: 'Pool authority (opens/resets/closes epochs).',
+            immutable: true,
+        },
+        registryId: {
+            type: 'uuid',
+            description: 'Identity-registry fiber id, bound via _addDependency (#24).',
+            immutable: true,
+        },
+        minReputation: {
+            type: 'integer',
+            description: 'Join reputation bar (signerHasReputationVia).',
+            immutable: true,
+        },
+        stakePolicy: {
+            type: 'string',
+            description: 'Asset policy name of the stake token.',
+            immutable: true,
+        },
+        stakeAmount: {
+            type: 'integer',
+            description: 'Required stake (minor units); checked vs heldAssets (H5).',
+            immutable: true,
+        },
+        quorum: {
+            type: 'integer',
+            description: 'Min submissions to finalize.',
+            immutable: true,
+        },
+        epochLength: {
+            type: 'integer',
+            description: 'Ordinals per epoch (submit window).',
+            immutable: true,
+        },
+        outlierBound: {
+            type: 'integer',
+            description: '|x - center| <= bound ⇒ in-consensus.',
+            immutable: true,
+        },
+        rewardPerEpoch: {
+            type: 'integer',
+            description: 'Informational per-epoch reward budget.',
+            immutable: true,
+        },
+    },
+};
+const baseStateSchema = {
+    properties: {
+        status: { type: 'string', computed: true },
+        epoch: { type: 'integer', computed: true },
+        epochStartedAt: { type: 'integer', computed: true },
+        authority: { type: 'address', immutable: true },
+        registryId: { type: 'uuid', immutable: true },
+        minReputation: { type: 'integer', immutable: true },
+        stakePolicy: { type: 'string', immutable: true },
+        stakeAmount: { type: 'integer', immutable: true },
+        quorum: { type: 'integer', immutable: true },
+        epochLength: { type: 'integer', immutable: true },
+        outlierBound: { type: 'integer', immutable: true },
+        rewardPerEpoch: { type: 'integer', immutable: true },
+        participants: {
+            type: 'object',
+            computed: true,
+            description: '{ <addr>: true } flat membership.',
+        },
+        stakes: {
+            type: 'object',
+            computed: true,
+            description: '{ <addr>: int } staked amount.',
+        },
+        stakeAssetIds: {
+            type: 'object',
+            computed: true,
+            description: '{ <addr>: uuid } staked instance.',
+        },
+        submissions: {
+            type: 'array',
+            computed: true,
+            description: "[ {addr,value} ] this epoch's datapoints.",
+        },
+        inConsensus: {
+            type: 'array',
+            computed: true,
+            description: "Last epoch's rewarded addresses (entitlement ledger).",
+        },
+        claimed: {
+            type: 'object',
+            computed: true,
+            description: '{ <addr>: true } reward already claimed this epoch.',
+        },
+        result: {
+            type: 'object',
+            computed: true,
+            nullable: true,
+            description: 'Last finalized published result.',
+        },
+        closedAt: { type: 'integer', computed: true },
+    },
+};
+/**
+ * Genesis state — EVERY map init'd to `{}` and EVERY array to `[]` so reads stay total (M1: `has`/`get`
+ * on null hard-error). `epoch`/`epochStartedAt` are 0 until `open_first_epoch`.
+ */
+export const baseInitialStateData = {
+    status: 'FORMING',
+    epoch: 0,
+    epochStartedAt: 0,
+    participants: {},
+    stakes: {},
+    stakeAssetIds: {},
+    submissions: [],
+    inConsensus: [],
+    claimed: {},
+    result: null,
+};
+const baseStates = {
+    FORMING: {
+        id: 'FORMING',
+        isFinal: false,
+        metadata: {
+            label: 'Forming',
+            description: 'Accepting stake/join; registry bound; no epoch yet.',
+            category: 'initial',
+        },
+    },
+    COLLECTING: {
+        id: 'COLLECTING',
+        isFinal: false,
+        metadata: {
+            label: 'Collecting',
+            description: 'Epoch open; participants submit datapoints.',
+            category: 'active',
+        },
+    },
+    SETTLED: {
+        id: 'SETTLED',
+        isFinal: false,
+        metadata: {
+            label: 'Settled',
+            description: 'Result published; entitlement ledger credited; readable cross-fiber.',
+            category: 'pending',
+        },
+    },
+    CLOSED: {
+        id: 'CLOSED',
+        isFinal: true,
+        metadata: {
+            label: 'Closed',
+            description: 'Wound down; stakes + unclaimed rewards still withdrawable/claimable.',
+            category: 'terminal',
+        },
+    },
+};
+/**
+ * Build a staked-pool definition from the shared base + a specialization's `submit`/`finalize` (+ extras).
+ * Emits all SPLIT multi-`from` arms; no two emitted entries share both `from` and `eventName`.
+ */
+export function makeStakedPoolDef(overrides) {
+    const submit = overrides.submit ?? defaultSubmitArm();
+    const transitions = [
+        bindRegistryArm(),
+        stakeAndJoinArm('FORMING'),
+        stakeAndJoinArm('COLLECTING'),
+        openFirstEpochArm(),
+        resetEpochArm(),
+        submit,
+        overrides.finalize,
+        claimRewardArm('SETTLED'),
+        claimRewardArm('CLOSED'),
+        withdrawStakeArm('SETTLED'),
+        withdrawStakeArm('CLOSED'),
+        closeArm('FORMING'),
+        closeArm('COLLECTING'),
+        closeArm('SETTLED'),
+        ...(overrides.extraTransitions ?? []),
+    ];
+    return defineFiberApp({
+        metadata: {
+            name: overrides.metadata.name,
+            app: 'staked-pool',
+            type: overrides.metadata.type,
+            version: overrides.metadata.version ?? '1.0.0',
+            description: overrides.metadata.description,
+        },
+        createSchema: {
+            required: baseCreateSchema.required,
+            properties: {
+                ...baseCreateSchema.properties,
+                ...(overrides.extraCreateProperties ?? {}),
+            },
+        },
+        stateSchema: {
+            properties: {
+                ...baseStateSchema.properties,
+                ...(overrides.extraStateProperties ?? {}),
+            },
+        },
+        states: { ...baseStates, ...(overrides.extraStates ?? {}) },
+        initialState: 'FORMING',
+        transitions,
+    });
+}

package/dist/esm/apps/staked-pool/consumer.js

@@ -0,0 +1,49 @@
+/**
+ * Cross-fiber consumer-read helpers for a SETTLED staked/oracle pool ("pull the answer").
+ *
+ * Two-phase (#24): a consumer first BINDS the pool dependency and PINS the epoch it intends to consume
+ * (transition N), then GATES on lifecycle + epoch and READS `result` (transition N+1). The epoch pin
+ * (M4) makes the read epoch-EXACT: between bind and read the pool can cycle SETTLED→COLLECTING→SETTLED,
+ * so a bare `depInState(SETTLED)` could read a DIFFERENT epoch's answer.
+ *
+ * Verified against the VM: `machines.<poolId>.state.{epoch,result}` reads resolve, and
+ * `depInState`/the epoch-`===` gate evaluate true only for the pinned, settled epoch.
+ */
+import { depInState } from '../../schema/guards.js';
+import { addDependency } from '../../schema/effects.js';
+const machineState = (poolIdVar) => ({
+    get: [{ get: [{ var: 'machines' }, { var: poolIdVar }] }, 'state'],
+});
+/**
+ * PHASE 1 effect fragment — bind the pool dependency AND pin its current epoch into `epochField`
+ * (default `"expectedPoolEpoch"`). Spread into the consumer's `merge` effect on the bind transition.
+ * NOTE: `machines.<poolId>` is only readable AFTER a prior `_addDependency`, so the epoch pin records the
+ * value the consumer observes at bind time; on the first bind the pool dep may be unbound and the pin
+ * resolves null — bind in one transition, pin in the next if the registry/pool was not yet a dependency.
+ */
+export function bindAndPinPoolEpoch(poolIdVar = 'state.poolId', epochField = 'expectedPoolEpoch') {
+    return {
+        [epochField]: { get: [machineState(poolIdVar), 'epoch'] },
+        ...addDependency({ var: poolIdVar }),
+    };
+}
+/**
+ * PHASE 2 guard — the pool is SETTLED for the EXACT epoch the consumer pinned. Compose into the read
+ * transition's guard alongside the consumer's own auth.
+ */
+export function poolSettledForPinnedEpoch(poolIdVar = 'state.poolId', epochField = 'state.expectedPoolEpoch') {
+    return {
+        and: [
+            depInState(poolIdVar, 'SETTLED'),
+            { '===': [{ get: [machineState(poolIdVar), 'epoch'] }, { var: epochField }] },
+        ],
+    };
+}
+/** PHASE 2 value read — the published `result` object (use `.value` for the scalar answer). */
+export function readPoolResult(poolIdVar = 'state.poolId') {
+    return { get: [machineState(poolIdVar), 'result'] };
+}
+/** PHASE 2 value read — the scalar `result.value`. */
+export function readPoolResultValue(poolIdVar = 'state.poolId') {
+    return { get: [{ get: [machineState(poolIdVar), 'result'] }, 'value'] };
+}

package/dist/esm/apps/staked-pool/index.js

@@ -0,0 +1,60 @@
+/**
+ * Staked-pool Application — a reusable staked-epoch-pool std-lib BASE plus an oracle-pool specialization.
+ *
+ * The base is a long-lived account-layer fiber proving the chain can carry real economic coordination:
+ * registry-gated, stake-backed membership; an append-only submission array; a state-resident claim
+ * entitlement ledger (zero finalize-time transfers); and one-whole-asset claim/withdraw custody moves.
+ * The oracle specialization adds an outlier-bounded (trimmed-mean) consensus aggregation whose published
+ * answer a consumer reads cross-fiber via an epoch-pinned `depInState(SETTLED)` gate.
+ *
+ * Composes EXISTING SDK primitives only (+ two helpers added this workstream — `transferAsset`,
+ * `actorNotInArray`): `signerIsParty` / `actorIsSigner` / `signerHasReputationVia` / `depInState`
+ * (`src/schema/guards.ts`), `addDependency` / `transferAsset` (`src/schema/effects.ts`), and the lending
+ * family's asset payload builders (`src/apps/lending/assets.ts`).
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   getStakedPoolDefinition,
+ *   makeOraclePoolDef,
+ *   stakePolicy,
+ *   rewardPotPolicy,
+ *   bindAndPinPoolEpoch,
+ *   poolSettledForPinnedEpoch,
+ *   readPoolResultValue,
+ * } from '@ottochain/sdk/apps/staked-pool';
+ *
+ * const oracle = getStakedPoolDefinition('oraclePool');
+ * const plainMean = makeOraclePoolDef({ aggregation: 'mean' });
+ * const stake = stakePolicy();
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { stakedPoolBaseDef, stakedPoolOracleDef } from './state-machines/index.js';
+export { stakedPoolBaseDef, stakedPoolOracleDef };
+/** All staked-pool state machine definitions. */
+export const STAKED_POOL_DEFINITIONS = {
+    base: stakedPoolBaseDef,
+    oraclePool: stakedPoolOracleDef,
+};
+/**
+ * Get a staked-pool state machine definition by type.
+ * @param type - 'base' | 'oraclePool' (default: 'oraclePool')
+ */
+export function getStakedPoolDefinition(type = 'oraclePool') {
+    return STAKED_POOL_DEFINITIONS[type];
+}
+// ---------------------------------------------------------------------------
+// Factory + base building blocks (for downstream specializations)
+// ---------------------------------------------------------------------------
+export { makeStakedPoolDef, defaultSubmitArm, baseInitialStateData } from './base.js';
+export { makeOraclePoolDef } from './state-machines/index.js';
+// ---------------------------------------------------------------------------
+// Asset-subsystem integration (stake + reward policies / lifecycle drivers)
+// ---------------------------------------------------------------------------
+export { stakePolicy, rewardPotPolicy, stakeJoinOp, mintRewardInstancesOp, createAssetPolicyPayload, createMintAssetPayload, createApplyMorphismPayload, fiberHolder, walletHolder, TokenBehaviors, } from './assets.js';
+// ---------------------------------------------------------------------------
+// Cross-fiber consumer-read interface ("pull the answer", epoch-pinned)
+// ---------------------------------------------------------------------------
+export { bindAndPinPoolEpoch, poolSettledForPinnedEpoch, readPoolResult, readPoolResultValue } from './consumer.js';

package/dist/esm/apps/staked-pool/state-machines/index.js

@@ -0,0 +1,6 @@
+/**
+ * Staked-pool state machine definitions.
+ * Re-exports from TypeScript definition files.
+ */
+export { stakedPoolBaseDef } from './staked-pool-base.js';
+export { stakedPoolOracleDef, makeOraclePoolDef, } from './staked-pool-oracle.js';

package/dist/esm/apps/staked-pool/state-machines/staked-pool-base.js

@@ -0,0 +1,46 @@
+/**
+ * The generic staked-pool BASE definition (`StakedPool`) — the reusable epoch-pool skeleton with a
+ * minimal pass-through `finalize` (authority settles; publishes a trivial result and an EMPTY in-consensus
+ * set, zero transfers). It is the lowest-common-denominator def; downstream apps should prefer a
+ * specialization (e.g. the oracle pool) that supplies real aggregation. Exposed for definition-validity
+ * round-tripping and as the explicit "base, unspecialized" instance.
+ */
+import { makeStakedPoolDef } from '../base.js';
+/** Minimal finalize: authority settles; no aggregation, empty entitlement set, zero transfers. */
+const baseFinalizeArm = {
+    from: 'COLLECTING',
+    to: 'SETTLED',
+    eventName: 'finalize',
+    guard: {
+        and: [
+            { in: [{ var: 'state.authority' }, { map: [{ var: 'proofs' }, { var: 'address' }] }] },
+            { '>=': [{ count: [{ var: 'state.submissions' }] }, { var: 'state.quorum' }] },
+        ],
+    },
+    effect: {
+        merge: [
+            { var: 'state' },
+            {
+                status: 'SETTLED',
+                inConsensus: [],
+                claimed: {},
+                result: {
+                    submissionCount: { count: [{ var: 'state.submissions' }] },
+                    epoch: { var: 'state.epoch' },
+                    finalizedAt: { var: '$ordinal' },
+                },
+            },
+        ],
+    },
+    dependencies: [],
+};
+export const stakedPoolBaseDef = makeStakedPoolDef({
+    metadata: {
+        name: 'StakedPool',
+        type: 'base',
+        description: 'Generic staked-epoch-pool base (FORMING→COLLECTING→SETTLED→COLLECTING…→CLOSED): registry-gated ' +
+            'join with stake custody, append-only submissions, a state-resident claim entitlement ledger, and ' +
+            'one-whole-asset claim/withdraw transfers. Specialize `submit`/`finalize` for a concrete pool.',
+    },
+    finalize: baseFinalizeArm,
+});