@ottochain/sdk 2.3.0 → 2.5.0

package/dist/types/apps/staked-pool/consumer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 type { JsonLogicRule } from '../../schema/fiber-app.js';
+/**
+ * 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 declare function bindAndPinPoolEpoch(poolIdVar?: string, epochField?: string): Record<string, unknown>;
+/**
+ * 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 declare function poolSettledForPinnedEpoch(poolIdVar?: string, epochField?: string): JsonLogicRule;
+/** PHASE 2 value read — the published `result` object (use `.value` for the scalar answer). */
+export declare function readPoolResult(poolIdVar?: string): JsonLogicRule;
+/** PHASE 2 value read — the scalar `result.value`. */
+export declare function readPoolResultValue(poolIdVar?: string): JsonLogicRule;

package/dist/types/apps/staked-pool/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 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';
+import type { FiberAppDefinition } from '../../schema/fiber-app.js';
+export { stakedPoolBaseDef, stakedPoolOracleDef };
+/** All staked-pool state machine definitions. */
+export declare const STAKED_POOL_DEFINITIONS: {
+    readonly base: FiberAppDefinition<string, string>;
+    readonly oraclePool: FiberAppDefinition<string, string>;
+};
+export type StakedPoolType = keyof typeof STAKED_POOL_DEFINITIONS;
+/**
+ * Get a staked-pool state machine definition by type.
+ * @param type - 'base' | 'oraclePool' (default: 'oraclePool')
+ */
+export declare function getStakedPoolDefinition(type?: StakedPoolType): FiberAppDefinition;
+export { makeStakedPoolDef, defaultSubmitArm, baseInitialStateData, type StakedPoolOverrides } from './base.js';
+export { makeOraclePoolDef, type OracleAggregation, type OraclePoolOptions } from './state-machines/index.js';
+export { stakePolicy, rewardPotPolicy, stakeJoinOp, mintRewardInstancesOp, createAssetPolicyPayload, createMintAssetPayload, createApplyMorphismPayload, fiberHolder, walletHolder, TokenBehaviors, type CreateAssetPolicyParams, type MintAssetMessage, type ApplyMorphismMessage, type PolicyRef, } from './assets.js';
+export { bindAndPinPoolEpoch, poolSettledForPinnedEpoch, readPoolResult, readPoolResultValue } from './consumer.js';

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

@@ -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, type OracleAggregation, type OraclePoolOptions, } from './staked-pool-oracle.js';

package/dist/types/apps/staked-pool/state-machines/staked-pool-base.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+export declare const stakedPoolBaseDef: import("../../../schema/fiber-app.js").FiberAppDefinition<string, string>;

package/dist/types/apps/staked-pool/state-machines/staked-pool-oracle.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Oracle-pool specialization of the staked-pool base (`StakedPoolOracle`).
+ *
+ * `submit` appends a numeric datapoint `{ addr, value }` (the base default arm).
+ * `finalize` (COLLECTING→SETTLED) aggregates the array with an outlier-bounded mean and publishes the
+ * answer + the in-consensus address set — emitting ZERO asset transfers (the entitlement ledger is
+ * `inConsensus`; rewards are pulled per-claim via the base `claim_reward` arm).
+ *
+ * Aggregation (default `trimmedMean`):
+ *   1. vals    = map(submissions, .value)
+ *   2. trimmed = filter(submissions, value != min(vals) && value != max(vals))   — drop single min + single max
+ *   3. center  = sum(trimmed.value) / count(trimmed)                              — EXACT rational (no truncation)
+ *   4. kept    = filter(submissions, abs(value - center) <= outlierBound)         — the in-consensus set
+ *   5. answer  = sum(kept.value) / count(kept)
+ *
+ * CRITICAL JLVM SCOPING (verified against @constellation-network/metagraph-sdk-jlvm@1.8.0-rc.5):
+ *   - Inside a `map`/`filter` callback the data scope is the BARE element, BUT the outer `state.*` is
+ *     still readable (verified: `{cat:[addr,"|",{var:"state.epoch"}]}` reads epoch correctly).
+ *   - A `let`-bound name does NOT cross into a `map`/`filter` callback. So `center` is INLINED into the
+ *     `kept` predicate (it reads `state.submissions`, which IS visible) rather than `let`-hoisted — a
+ *     `let`-bound `center` resolves to null inside `filter`, evicting every submission (div-by-zero).
+ *   - A `reduce` with a MAP initial accumulator is rejected (`opReduce` requires `isPrimitive(init)`),
+ *     so the reward ledger is NOT a folded `{addr:int}` map — it is the `inConsensus` array (membership =
+ *     entitlement), consumed by `claim_reward` + a `claimed` dedup map.
+ */
+export type OracleAggregation = 'mean' | 'trimmedMean';
+export interface OraclePoolOptions {
+    /** Aggregation strategy. Default `trimmedMean` (drop single min + single max — the robustness ceiling). */
+    aggregation?: OracleAggregation;
+}
+/** Build the oracle-pool definition. `outlierPenalty` is soft-only (no-credit for outliers); hard slash is v2. */
+export declare function makeOraclePoolDef(options?: OraclePoolOptions): import("../../../schema/fiber-app.js").FiberAppDefinition<string, string>;
+/** Default oracle-pool definition (trimmed-mean). */
+export declare const stakedPoolOracleDef: import("../../../schema/fiber-app.js").FiberAppDefinition<string, string>;

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

@@ -19,11 +19,11 @@
 export { FiberStatus, AccessControlPolicy, PublicAccess, WhitelistAccess, FiberOwnedAccess, StateMachineDefinition, EmittedEvent, EventReceipt, ScriptInvocation, FiberLogEntry, } from './ottochain/v1/fiber.js';
 export { CreateStateMachine, TransitionStateMachine, ArchiveStateMachine, CreateScript, InvokeScript, OttochainMessage, } from './ottochain/v1/messages.js';
 export { StateMachineFiberRecord, ScriptFiberRecord, FiberCommit, OnChainState, CalculatedState, } from './ottochain/v1/records.js';
-export { IdentityType, IdentityState, Platform, PlatformLink, Reputation, PenaltyEvent, Identity, RegisterIdentityRequest, ActivateIdentityRequest, LinkPlatformRequest, ChallengeIdentityRequest, AddStakeRequest, WithdrawIdentityRequest, IdentityDefinition, } from './ottochain/apps/identity/v1/identity.js';
-export { IdentityState as AgentState } from './ottochain/apps/identity/v1/identity.js';
-export { IdentityState as OracleState } from './ottochain/apps/identity/v1/identity.js';
+export { Type as IdentityType, State as IdentityState, Platform, PlatformLink, Reputation, PenaltyEvent, Identity, RegisterIdentityRequest, ActivateIdentityRequest, LinkPlatformRequest, ChallengeIdentityRequest, AddStakeRequest, WithdrawIdentityRequest, IdentityDefinition, } from './ottochain/apps/identity/v1/identity.js';
+export { State as AgentState } from './ottochain/apps/identity/v1/identity.js';
+export { State as OracleState } from './ottochain/apps/identity/v1/identity.js';
 export { AttestationType, ReputationDelta, Attestation, VouchRequest, ChallengeRequest, ReputationConfig, } from './ottochain/apps/identity/v1/attestation.js';
-export { ContractState, Contract, ProposeContractRequest, AcceptContractRequest, CompleteContractRequest, RejectContractRequest, DisputeContractRequest, ContractDefinition, } from './ottochain/apps/contracts/v1/contract.js';
-export { MarketType, MarketState, Commitment, Resolution, Market, CreateMarketRequest, CommitToMarketRequest, SubmitResolutionRequest, CancelMarketRequest, MarketDefinition, } from './ottochain/apps/markets/v1/market.js';
+export { State as ContractState, Contract, ProposeContractRequest, AcceptContractRequest, CompleteContractRequest, RejectContractRequest, DisputeContractRequest, ContractDefinition, } from './ottochain/apps/contracts/v1/contract.js';
+export { Type as MarketType, State as MarketState, Commitment, Resolution, Market, CreateMarketRequest, CommitToMarketRequest, SubmitResolutionRequest, CancelMarketRequest, MarketDefinition, } from './ottochain/apps/markets/v1/market.js';
 export { DAOType, DAOStatus, ProposalStatus, VoteChoice, DAOMetadata, Proposal, Vote, VoteTally, SingleOwnerDAO, SingleOwnerAction, OwnershipTransfer, MultisigDAO, MultisigAction, TokenDAO, TokenProposalResult, ThresholdDAO, ThresholdVotes, ThresholdHistoryEntry, CreateDAORequest, ProposeRequest, VoteRequest, ExecuteRequest, } from './ottochain/apps/governance/v1/governance.js';
 export { EntityType, EntityState, DirectorStatus, OfficerStatus, BoardMeetingType, ResolutionStatus, Jurisdiction, ShareClass, CorporateEntity, RegisteredAgent, Incorporator, ShareStructure, CorporateBoard, Director, SeatInfo, QuorumRules, BoardMeeting, MeetingAttendee, CorporateOfficers, Officer, OfficerAction, CorporateShareholders, Shareholder, ShareHolding, CorporateResolution, ResolutionVote, CorporateSecurities, SecurityIssuance, SecurityTransfer, CorporateCompliance, FilingRecord, ComplianceRequirement, CreateEntityRequest, AppointDirectorRequest, IssueSharesRequest, ProposeResolutionRequest, } from './ottochain/apps/corporate/v1/corporate.js';