@ottochain/sdk 0.2.0

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

@@ -0,0 +1,77 @@
+/**
+ * Governance & DAO Application
+ *
+ * Types and utilities for DAO governance on OttoChain.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   DAOType,
+ *   DAOStatus,
+ *   MultisigDAO,
+ *   getDAODefinition
+ * } from '@ottochain/sdk/apps/governance';
+ *
+ * const multisigDef = getDAODefinition('Multisig');
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { DAOType, DAOStatus, ProposalStatus, VoteChoice, DAOMetadata, Proposal, Vote, VoteTally, SingleOwnerDAO, SingleOwnerAction, OwnershipTransfer, MultisigDAO, MultisigAction, TokenDAO, TokenProposalResult, ThresholdDAO, ThresholdVotes, ThresholdHistoryEntry, CreateDAORequest, ProposeRequest, VoteRequest, ExecuteRequest, dAOTypeFromJSON, dAOTypeToJSON, dAOStatusFromJSON, dAOStatusToJSON, proposalStatusFromJSON, proposalStatusToJSON, voteChoiceFromJSON, voteChoiceToJSON, } from '../../generated/ottochain/apps/governance/v1/governance.js';
+export type DAODefinitionType = 'Single' | 'Multisig' | 'Threshold' | 'Token';
+export type GovernanceDefinitionType = 'Legislature' | 'Executive' | 'Judiciary' | 'Constitution' | 'Simple';
+export declare const DAO_DEFINITIONS: Record<DAODefinitionType, unknown>;
+export declare const GOVERNANCE_DEFINITIONS: Record<GovernanceDefinitionType, unknown>;
+/**
+ * Get the state machine definition for a DAO type.
+ */
+export declare function getDAODefinition(daoType: DAODefinitionType): unknown;
+/**
+ * Get the state machine definition for a governance type.
+ */
+export declare function getGovernanceDefinition(governanceType: GovernanceDefinitionType): unknown;
+import type { MultisigDAO, TokenDAO, ThresholdDAO } from '../../generated/ottochain/apps/governance/v1/governance.js';
+/**
+ * Check if multisig has enough signatures to execute
+ */
+export declare function isThresholdMet(state: MultisigDAO): boolean;
+/**
+ * Get remaining signatures needed
+ */
+export declare function signaturesNeeded(state: MultisigDAO): number;
+/**
+ * Check if agent is a signer
+ */
+export declare function isSigner(state: MultisigDAO, agent: string): boolean;
+/**
+ * Check if agent has signed current proposal
+ */
+export declare function hasSigned(state: MultisigDAO, agent: string): boolean;
+/**
+ * Get effective voting power (includes delegation)
+ */
+export declare function getVotingPower(state: TokenDAO, agent: string): number;
+/**
+ * Check if proposal has quorum
+ */
+export declare function hasQuorum(state: TokenDAO): boolean;
+/**
+ * Check if proposal is passing
+ */
+export declare function isPassing(state: TokenDAO): boolean;
+/**
+ * Check if agent can propose
+ */
+export declare function canPropose(state: TokenDAO, agent: string): boolean;
+/**
+ * Check if agent meets threshold for action
+ */
+export declare function meetsThreshold(state: ThresholdDAO, reputation: number, action: 'member' | 'vote' | 'propose'): boolean;
+/**
+ * Check if agent is a member
+ */
+export declare function isMember(state: ThresholdDAO, agent: string): boolean;
+/**
+ * Check if threshold proposal has quorum
+ */
+export declare function thresholdHasQuorum(state: ThresholdDAO): boolean;

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

@@ -0,0 +1,344 @@
+/**
+ * Governance & DAO Types
+ *
+ * TypeScript types matching the JSON Logic state machine definitions
+ * in ottochain/docs/trust-graph/state-machines/dao/
+ *
+ * @packageDocumentation
+ */
+/**
+ * DAO status values (matches JSON schema status field)
+ */
+export type DAOStatus = 'ACTIVE' | 'DISSOLVED';
+/**
+ * Proposal status for voting DAOs
+ */
+export type ProposalStatus = 'ACTIVE' | 'PENDING' | 'VOTING' | 'QUEUED' | 'EXECUTED' | 'REJECTED' | 'CANCELLED';
+/**
+ * Vote choice
+ */
+export type VoteChoice = 'for' | 'against' | 'abstain';
+/**
+ * Base metadata for all DAOs
+ */
+export interface DAOMetadata {
+    description?: string;
+    website?: string;
+    logo?: string;
+    [key: string]: unknown;
+}
+/**
+ * Single owner DAO state.
+ * One address controls all actions. Simplest governance model.
+ */
+export interface SingleOwnerDAOState {
+    schema: 'SingleOwnerDAO';
+    name: string;
+    owner: string;
+    pendingOwner: string | null;
+    transferInitiatedAt: number | null;
+    actions: SingleOwnerAction[];
+    ownershipHistory: OwnershipTransfer[];
+    metadata: DAOMetadata;
+    status: DAOStatus;
+}
+export interface SingleOwnerAction {
+    id: string;
+    type: string;
+    payload: unknown;
+    executedAt: number;
+}
+export interface OwnershipTransfer {
+    from: string;
+    to: string;
+    at: number;
+}
+/**
+ * Events for SingleOwnerDAO
+ */
+export type SingleOwnerEvent = {
+    eventName: 'execute';
+    agent: string;
+    actionId: string;
+    actionType: string;
+    payload: unknown;
+} | {
+    eventName: 'transfer_ownership';
+    agent: string;
+    newOwner: string;
+} | {
+    eventName: 'accept_ownership';
+    agent: string;
+} | {
+    eventName: 'cancel_transfer';
+    agent: string;
+} | {
+    eventName: 'dissolve';
+    agent: string;
+};
+/**
+ * Multisig DAO state.
+ * N-of-M signatures required for actions.
+ */
+export interface MultisigDAOState {
+    schema: 'MultisigDAO';
+    name: string;
+    signers: string[];
+    threshold: number;
+    proposalTTLMs: number;
+    proposal: MultisigProposal | null;
+    signatures: Record<string, number>;
+    actions: MultisigAction[];
+    cancelledProposals: MultisigProposal[];
+    metadata: DAOMetadata;
+    status: DAOStatus;
+}
+export interface MultisigProposal {
+    id: string;
+    actionType: string;
+    payload: unknown;
+    proposer: string;
+    proposedAt: number;
+    expiresAt: number;
+}
+export interface MultisigAction extends MultisigProposal {
+    signatures: Record<string, number>;
+    executedAt: number;
+}
+/**
+ * Events for MultisigDAO
+ */
+export type MultisigEvent = {
+    eventName: 'propose';
+    agent: string;
+    proposalId: string;
+    actionType: string;
+    payload: unknown;
+} | {
+    eventName: 'sign';
+    agent: string;
+} | {
+    eventName: 'execute';
+    agent: string;
+} | {
+    eventName: 'cancel';
+    agent: string;
+} | {
+    eventName: 'propose_add_signer';
+    agent: string;
+    proposalId: string;
+    newSigner: string;
+} | {
+    eventName: 'propose_remove_signer';
+    agent: string;
+    proposalId: string;
+    removeSigner: string;
+} | {
+    eventName: 'propose_change_threshold';
+    agent: string;
+    proposalId: string;
+    newThreshold: number;
+} | {
+    eventName: 'apply_signer_change';
+    agent: string;
+} | {
+    eventName: 'dissolve';
+    agent: string;
+    signatureCount: number;
+};
+/**
+ * Token DAO state.
+ * Token-weighted voting. Voting power proportional to holdings.
+ */
+export interface TokenDAOState {
+    schema: 'TokenDAO';
+    name: string;
+    tokenId: string;
+    balances: Record<string, number>;
+    delegations: Record<string, string>;
+    proposalThreshold: number;
+    votingPeriodMs: number;
+    timelockMs: number;
+    quorum: number;
+    proposal: TokenProposal | null;
+    votes: TokenVotes | null;
+    executedProposals: TokenProposalResult[];
+    rejectedProposals: TokenProposalResult[];
+    cancelledProposals: TokenProposal[];
+    metadata: DAOMetadata;
+    status: DAOStatus;
+}
+export interface TokenProposal {
+    id: string;
+    title: string;
+    description: string;
+    actionType: string;
+    payload: unknown;
+    proposer: string;
+    proposedAt: number;
+    votingEndsAt: number;
+    snapshotBlock?: number;
+    queuedAt?: number;
+    executableAt?: number;
+}
+export interface TokenVotes {
+    for: number;
+    against: number;
+    abstain: number;
+    voters: Record<string, TokenVote>;
+}
+export interface TokenVote {
+    vote: VoteChoice;
+    weight: number;
+    votedAt: number;
+}
+export interface TokenProposalResult extends TokenProposal {
+    votes: TokenVotes;
+    executedAt?: number;
+    rejectedAt?: number;
+}
+/**
+ * Events for TokenDAO
+ */
+export type TokenEvent = {
+    eventName: 'propose';
+    agent: string;
+    proposalId: string;
+    title: string;
+    description: string;
+    actionType: string;
+    payload: unknown;
+    snapshotBlock?: number;
+} | {
+    eventName: 'vote';
+    agent: string;
+    vote: VoteChoice;
+} | {
+    eventName: 'queue';
+    agent: string;
+} | {
+    eventName: 'execute';
+    agent: string;
+} | {
+    eventName: 'reject';
+    agent: string;
+} | {
+    eventName: 'cancel';
+    agent: string;
+} | {
+    eventName: 'delegate';
+    agent: string;
+    delegateTo: string;
+} | {
+    eventName: 'undelegate';
+    agent: string;
+};
+/**
+ * Threshold DAO state.
+ * Reputation-based governance. Minimum reputation required for participation.
+ */
+export interface ThresholdDAOState {
+    schema: 'ThresholdDAO';
+    name: string;
+    members: string[];
+    memberJoinedAt: Record<string, number>;
+    memberThreshold: number;
+    voteThreshold: number;
+    proposeThreshold: number;
+    quorum: number;
+    votingPeriodMs: number;
+    proposal: ThresholdProposal | null;
+    votes: ThresholdVotes | null;
+    history: ThresholdHistoryEntry[];
+    metadata: DAOMetadata;
+    status: DAOStatus;
+}
+export interface ThresholdProposal {
+    id: string;
+    title: string;
+    description?: string;
+    actionType: string;
+    payload: unknown;
+    proposer: string;
+    proposedAt: number;
+    deadline: number;
+}
+export interface ThresholdVotes {
+    for: string[];
+    against: string[];
+    abstain: string[];
+}
+export interface ThresholdHistoryEntry {
+    type: 'executed' | 'rejected';
+    proposal: ThresholdProposal;
+    votes: ThresholdVotes;
+    at: number;
+}
+/**
+ * Events for ThresholdDAO
+ * Note: agentReputation is passed in from the reputation oracle
+ */
+export type ThresholdEvent = {
+    eventName: 'propose';
+    agent: string;
+    agentReputation: number;
+    proposalId: string;
+    title: string;
+    description?: string;
+    actionType: string;
+    payload: unknown;
+} | {
+    eventName: 'vote';
+    agent: string;
+    agentReputation: number;
+    vote: VoteChoice;
+} | {
+    eventName: 'execute';
+    agent: string;
+} | {
+    eventName: 'reject';
+    agent: string;
+} | {
+    eventName: 'join';
+    agent: string;
+    agentReputation: number;
+} | {
+    eventName: 'leave';
+    agent: string;
+} | {
+    eventName: 'propose_threshold_change';
+    agent: string;
+    agentReputation: number;
+    proposalId: string;
+    memberThreshold?: number;
+    voteThreshold?: number;
+    proposeThreshold?: number;
+};
+/**
+ * Any DAO state
+ */
+export type DAOState = SingleOwnerDAOState | MultisigDAOState | TokenDAOState | ThresholdDAOState;
+/**
+ * Any DAO event
+ */
+export type DAOEvent = SingleOwnerEvent | MultisigEvent | TokenEvent | ThresholdEvent;
+/**
+ * DAO schema names for type discrimination
+ */
+export type DAOSchema = 'SingleOwnerDAO' | 'MultisigDAO' | 'TokenDAO' | 'ThresholdDAO';
+/**
+ * Type guard for SingleOwnerDAO
+ */
+export declare function isSingleOwnerDAO(state: DAOState): state is SingleOwnerDAOState;
+/**
+ * Type guard for MultisigDAO
+ */
+export declare function isMultisigDAO(state: DAOState): state is MultisigDAOState;
+/**
+ * Type guard for TokenDAO
+ */
+export declare function isTokenDAO(state: DAOState): state is TokenDAOState;
+/**
+ * Type guard for ThresholdDAO
+ */
+export declare function isThresholdDAO(state: DAOState): state is ThresholdDAOState;

package/dist/types/apps/identity/constants.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Identity Constants
+ *
+ * State machine transitions and configuration constants for agent identity.
+ *
+ * @packageDocumentation
+ */
+import { AgentState } from '../../generated/ottochain/apps/identity/v1/agent.js';
+import { AttestationType } from '../../generated/ottochain/apps/identity/v1/attestation.js';
+/**
+ * Valid transitions for each agent state.
+ * Maps current state to allowed event names.
+ */
+export declare const AGENT_TRANSITIONS: Record<AgentState, readonly string[]>;
+/**
+ * Reputation delta by attestation type.
+ * These values match the metagraph state machine defaults.
+ */
+export declare const ATTESTATION_DELTAS: Record<AttestationType, number>;
+/**
+ * Check if a transition is valid for the given state.
+ */
+export declare function canTransition(state: AgentState, event: string): boolean;
+/**
+ * Get reputation delta for an attestation type.
+ */
+export declare function getReputationDelta(type: AttestationType): number;

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

@@ -0,0 +1,39 @@
+/**
+ * Agent Identity Application
+ *
+ * Types and utilities for the Agent Identity system on OttoChain.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   AgentState,
+ *   AgentIdentity,
+ *   getIdentityDefinition
+ * } from '@ottochain/sdk/apps/identity';
+ *
+ * const identityDef = getIdentityDefinition();
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { AgentState, Platform, PlatformLink, AgentIdentity, AgentIdentityDefinition, agentStateFromJSON, agentStateToJSON, platformFromJSON, platformToJSON, } from '../../generated/ottochain/apps/identity/v1/agent.js';
+export { AttestationType, ReputationDelta, Attestation, VouchRequest, ChallengeRequest, ReputationConfig, attestationTypeFromJSON, attestationTypeToJSON, } from '../../generated/ottochain/apps/identity/v1/attestation.js';
+export { AGENT_TRANSITIONS, ATTESTATION_DELTAS, canTransition, getReputationDelta, } from './constants.js';
+/**
+ * Default reputation configuration for agent identity
+ */
+export declare const DEFAULT_REPUTATION_CONFIG: {
+    readonly baseReputation: 10;
+    readonly completionDelta: 5;
+    readonly vouchDelta: 2;
+    readonly violationDelta: -10;
+    readonly behavioralDelta: 3;
+    readonly minReputation: 0;
+    readonly challengeThreshold: 5;
+};
+/**
+ * Get the agent identity state machine definition.
+ *
+ * @returns The state machine definition JSON for AgentIdentity
+ */
+export declare function getIdentityDefinition(): unknown;

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

@@ -0,0 +1,30 @@
+/**
+ * Agent Identity Utilities
+ *
+ * Constants and utilities for the Agent Identity application.
+ * Core types are generated from protobuf - see the generated exports.
+ *
+ * @packageDocumentation
+ */
+import { AgentState } from '../../generated/ottochain/apps/identity/v1/agent_pb.js';
+import { AttestationType } from '../../generated/ottochain/apps/identity/v1/attestation_pb.js';
+/**
+ * Default reputation configuration for agent identity
+ */
+export declare const DEFAULT_REPUTATION_CONFIG: {
+    readonly baseReputation: 10;
+    readonly completionDelta: 5;
+    readonly vouchDelta: 2;
+    readonly violationDelta: -10;
+    readonly behavioralDelta: 3;
+    readonly minReputation: 0;
+    readonly challengeThreshold: 5;
+};
+/**
+ * Valid transitions for each agent state
+ */
+export declare const AGENT_TRANSITIONS: Record<AgentState, readonly string[]>;
+/**
+ * Reputation delta by attestation type
+ */
+export declare const ATTESTATION_DELTAS: Record<AttestationType, number>;

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

@@ -0,0 +1,31 @@
+/**
+ * OttoChain Applications
+ *
+ * Application-specific types and utilities for OttoChain SDK.
+ *
+ * @example
+ * ```typescript
+ * import { identity, contracts, markets, oracles, governance } from '@ottochain/sdk/apps';
+ *
+ * // Use identity types
+ * const { AgentState } = identity;
+ *
+ * // Check oracle reputation
+ * const state = oracles.OracleState.ACTIVE;
+ *
+ * // Create a multisig DAO
+ * const dao = governance.createMultisigState({
+ *   name: 'Treasury',
+ *   signers: ['DAG...', 'DAG...', 'DAG...'],
+ *   threshold: 2
+ * });
+ * ```
+ *
+ * @packageDocumentation
+ */
+export * as identity from './identity/index.js';
+export * as contracts from './contracts/index.js';
+export * as markets from './markets/index.js';
+export * as oracles from './oracles/index.js';
+export * as governance from './governance/index.js';
+export * as corporate from './corporate/index.js';

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

@@ -0,0 +1,26 @@
+/**
+ * Markets Application
+ *
+ * Types and utilities for prediction markets on OttoChain.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   MarketType,
+ *   MarketState,
+ *   Market,
+ *   getMarketDefinition
+ * } from '@ottochain/sdk/apps/markets';
+ *
+ * const marketDef = getMarketDefinition();
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { MarketType, MarketState, Commitment, Resolution, Market, CreateMarketRequest, CommitToMarketRequest, SubmitResolutionRequest, CancelMarketRequest, MarketDefinition, marketTypeFromJSON, marketTypeToJSON, marketStateFromJSON, marketStateToJSON, } from '../../generated/ottochain/apps/markets/v1/market.js';
+export type MarketDefinitionType = 'Universal';
+export declare const MARKET_DEFINITIONS: Record<MarketDefinitionType, unknown>;
+/**
+ * Get the market state machine definition.
+ */
+export declare function getMarketDefinition(type?: MarketDefinitionType): unknown;