@ottochain/sdk 1.0.3 → 1.1.0

package/dist/errors.js

@@ -1,293 +0,0 @@
-"use strict";
-/**
- * Custom Error Classes for OttoChain SDK
- *
- * Provides structured error handling with error codes and causes.
- *
- * @packageDocumentation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapError = exports.isErrorCode = exports.TransactionError = exports.SigningError = exports.ValidationError = exports.NetworkError = exports.OttoChainError = exports.ErrorCode = void 0;
-/**
- * Error codes for OttoChain SDK errors
- */
-var ErrorCode;
-(function (ErrorCode) {
-    /** Unknown or unclassified error */
-    ErrorCode["UNKNOWN"] = "UNKNOWN";
-    /** Network/HTTP connection failure */
-    ErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
-    /** Request timeout */
-    ErrorCode["NETWORK_TIMEOUT"] = "NETWORK_TIMEOUT";
-    /** Input validation failed */
-    ErrorCode["VALIDATION_ERROR"] = "VALIDATION_ERROR";
-    /** Invalid private key format */
-    ErrorCode["INVALID_PRIVATE_KEY"] = "INVALID_PRIVATE_KEY";
-    /** Invalid public key format */
-    ErrorCode["INVALID_PUBLIC_KEY"] = "INVALID_PUBLIC_KEY";
-    /** Invalid DAG address format */
-    ErrorCode["INVALID_ADDRESS"] = "INVALID_ADDRESS";
-    /** Signature creation failed */
-    ErrorCode["SIGNING_ERROR"] = "SIGNING_ERROR";
-    /** Signature verification failed */
-    ErrorCode["VERIFICATION_ERROR"] = "VERIFICATION_ERROR";
-    /** Transaction rejected by network */
-    ErrorCode["TRANSACTION_REJECTED"] = "TRANSACTION_REJECTED";
-    /** Transaction not found */
-    ErrorCode["TRANSACTION_NOT_FOUND"] = "TRANSACTION_NOT_FOUND";
-    /** Invalid transaction format */
-    ErrorCode["INVALID_TRANSACTION"] = "INVALID_TRANSACTION";
-})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
-/**
- * Base error class for all OttoChain SDK errors
- *
- * Provides consistent error structure with:
- * - Error code for programmatic handling
- * - Human-readable message
- * - Optional cause for error chaining
- *
- * @example
- * ```typescript
- * try {
- *   await signTransaction(data, invalidKey);
- * } catch (error) {
- *   if (error instanceof OttoChainError) {
- *     console.log(error.code);    // 'INVALID_PRIVATE_KEY'
- *     console.log(error.message); // 'Invalid private key format'
- *   }
- * }
- * ```
- */
-class OttoChainError extends Error {
-    constructor(code, message, cause) {
-        super(message);
-        this.name = 'OttoChainError';
-        this.code = code;
-        this.cause = cause;
-        // Maintains proper stack trace for where error was thrown (V8 engines)
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, this.constructor);
-        }
-    }
-    /**
-     * Create a string representation of the error
-     */
-    toString() {
-        let result = `${this.name} [${this.code}]: ${this.message}`;
-        if (this.cause) {
-            result += `\nCaused by: ${this.cause.message}`;
-        }
-        return result;
-    }
-    /**
-     * Convert error to a plain object for logging/serialization
-     */
-    toJSON() {
-        return {
-            name: this.name,
-            code: this.code,
-            message: this.message,
-            cause: this.cause?.message,
-            stack: this.stack,
-        };
-    }
-}
-exports.OttoChainError = OttoChainError;
-/**
- * Error thrown when network operations fail
- *
- * Covers HTTP failures, connection errors, and timeouts.
- *
- * @example
- * ```typescript
- * try {
- *   await client.postTransaction(signed);
- * } catch (error) {
- *   if (error instanceof NetworkError) {
- *     console.log(error.statusCode); // 503
- *     console.log(error.responseBody); // '{"error": "Service unavailable"}'
- *   }
- * }
- * ```
- */
-class NetworkError extends OttoChainError {
-    constructor(message, statusCode, responseBody, cause) {
-        const code = statusCode === undefined ? ErrorCode.NETWORK_ERROR : ErrorCode.NETWORK_ERROR;
-        super(code, message, cause);
-        this.name = 'NetworkError';
-        this.statusCode = statusCode;
-        this.responseBody = responseBody;
-    }
-    /**
-     * Create a timeout error
-     */
-    static timeout(timeoutMs) {
-        const error = new NetworkError(`Request timed out after ${timeoutMs}ms`);
-        error.code = ErrorCode.NETWORK_TIMEOUT;
-        return error;
-    }
-    toJSON() {
-        return {
-            ...super.toJSON(),
-            statusCode: this.statusCode,
-            responseBody: this.responseBody,
-        };
-    }
-}
-exports.NetworkError = NetworkError;
-/**
- * Error thrown when input validation fails
- *
- * Used when function parameters don't meet expected format or constraints.
- *
- * @example
- * ```typescript
- * try {
- *   const keyPair = keyPairFromPrivateKey('invalid');
- * } catch (error) {
- *   if (error instanceof ValidationError) {
- *     console.log(error.field); // 'privateKey'
- *     console.log(error.value); // 'invalid'
- *   }
- * }
- * ```
- */
-class ValidationError extends OttoChainError {
-    constructor(message, options) {
-        super(ErrorCode.VALIDATION_ERROR, message, options?.cause);
-        this.name = 'ValidationError';
-        this.field = options?.field;
-        this.value = options?.value;
-        this.details = options?.details;
-    }
-    toJSON() {
-        return {
-            ...super.toJSON(),
-            field: this.field,
-            value: this.value,
-            details: this.details,
-        };
-    }
-}
-exports.ValidationError = ValidationError;
-/**
- * Error thrown when cryptographic signing operations fail
- *
- * Covers key derivation, signature creation, and related crypto operations.
- *
- * @example
- * ```typescript
- * try {
- *   const signature = await signHash(hash, privateKey);
- * } catch (error) {
- *   if (error instanceof SigningError) {
- *     console.log(error.operation); // 'sign'
- *   }
- * }
- * ```
- */
-class SigningError extends OttoChainError {
-    constructor(message, options) {
-        super(ErrorCode.SIGNING_ERROR, message, options?.cause);
-        this.name = 'SigningError';
-        this.operation = options?.operation;
-    }
-    toJSON() {
-        return {
-            ...super.toJSON(),
-            operation: this.operation,
-        };
-    }
-}
-exports.SigningError = SigningError;
-/**
- * Error thrown when transaction operations fail
- *
- * Used when transactions are rejected, not found, or invalid.
- *
- * @example
- * ```typescript
- * try {
- *   await client.postTransaction(signed);
- * } catch (error) {
- *   if (error instanceof TransactionError) {
- *     console.log(error.transactionHash); // 'abc123...'
- *     console.log(error.rejectionReason); // 'Insufficient balance'
- *   }
- * }
- * ```
- */
-class TransactionError extends OttoChainError {
-    constructor(code, message, options) {
-        super(code, message, options?.cause);
-        this.name = 'TransactionError';
-        this.transactionHash = options?.transactionHash;
-        this.rejectionReason = options?.rejectionReason;
-    }
-    /**
-     * Create a transaction rejected error
-     */
-    static rejected(reason, transactionHash) {
-        return new TransactionError(ErrorCode.TRANSACTION_REJECTED, `Transaction rejected: ${reason}`, {
-            transactionHash,
-            rejectionReason: reason,
-        });
-    }
-    /**
-     * Create a transaction not found error
-     */
-    static notFound(transactionHash) {
-        return new TransactionError(ErrorCode.TRANSACTION_NOT_FOUND, `Transaction not found: ${transactionHash}`, {
-            transactionHash,
-        });
-    }
-    /**
-     * Create an invalid transaction error
-     */
-    static invalid(message, cause) {
-        return new TransactionError(ErrorCode.INVALID_TRANSACTION, message, { cause });
-    }
-    toJSON() {
-        return {
-            ...super.toJSON(),
-            transactionHash: this.transactionHash,
-            rejectionReason: this.rejectionReason,
-        };
-    }
-}
-exports.TransactionError = TransactionError;
-/**
- * Check if an error is an OttoChain error with a specific code
- *
- * @param error - Error to check
- * @param code - Error code to match
- * @returns True if error matches the code
- *
- * @example
- * ```typescript
- * if (isErrorCode(error, ErrorCode.NETWORK_TIMEOUT)) {
- *   // Retry the request
- * }
- * ```
- */
-function isErrorCode(error, code) {
-    return error instanceof OttoChainError && error.code === code;
-}
-exports.isErrorCode = isErrorCode;
-/**
- * Wrap an unknown error in an OttoChainError
- *
- * @param error - Error to wrap
- * @param defaultMessage - Default message if error has no message
- * @returns OttoChainError wrapping the original error
- */
-function wrapError(error, defaultMessage = 'An error occurred') {
-    if (error instanceof OttoChainError) {
-        return error;
-    }
-    if (error instanceof Error) {
-        return new OttoChainError(ErrorCode.UNKNOWN, error.message || defaultMessage, error);
-    }
-    return new OttoChainError(ErrorCode.UNKNOWN, String(error) || defaultMessage);
-}
-exports.wrapError = wrapError;

package/dist/esm/apps/contracts/types.js

@@ -1,44 +0,0 @@
-/**
- * Contract Utilities
- *
- * Constants and utilities for the Contract application.
- * Core types are generated from protobuf - see the generated exports.
- *
- * @packageDocumentation
- */
-import { ContractState } from '../../generated/ottochain/apps/contracts/v1/contract_pb.js';
-// ---------------------------------------------------------------------------
-// Configuration Defaults
-// ---------------------------------------------------------------------------
-/**
- * Default contract configuration
- */
-export const DEFAULT_CONTRACT_CONFIG = {
-    requireBothSignatures: false,
-    disputeWindowEpochs: 10,
-};
-// ---------------------------------------------------------------------------
-// State Machine Transitions
-// ---------------------------------------------------------------------------
-/**
- * Valid transitions for each contract state
- */
-export const CONTRACT_TRANSITIONS = {
-    [ContractState.UNSPECIFIED]: [],
-    [ContractState.PROPOSED]: ['accept', 'reject', 'cancel'],
-    [ContractState.ACTIVE]: ['complete', 'dispute'],
-    [ContractState.DISPUTED]: ['resolve_for_completer', 'resolve_for_disputant'],
-    [ContractState.COMPLETED]: [], // Terminal state
-    [ContractState.REJECTED]: [], // Terminal state
-    [ContractState.CANCELLED]: [], // Terminal state
-};
-/**
- * Check if a contract state is terminal (no further transitions allowed)
- */
-export function isTerminalState(state) {
-    return [
-        ContractState.COMPLETED,
-        ContractState.REJECTED,
-        ContractState.CANCELLED,
-    ].includes(state);
-}

package/dist/esm/apps/corporate/types.js

@@ -1,38 +0,0 @@
-/**
- * Corporate Governance type definitions
- *
- * TypeScript interfaces for corporate governance state machines covering
- * entity lifecycle, board management, shareholder meetings, officers,
- * bylaws, committees, resolutions, proxy voting, securities, and compliance.
- *
- * @see corporate/*.json for JSON state machine definitions
- * @packageDocumentation
- */
-// ---------------------------------------------------------------------------
-// State Machine Imports
-// ---------------------------------------------------------------------------
-import CorporateEntityDefinition from './state-machines/corporate-entity.json';
-import CorporateBoardDefinition from './state-machines/corporate-board.json';
-import CorporateShareholdersDefinition from './state-machines/corporate-shareholders.json';
-import CorporateOfficersDefinition from './state-machines/corporate-officers.json';
-import CorporateBylawsDefinition from './state-machines/corporate-bylaws.json';
-import CorporateCommitteeDefinition from './state-machines/corporate-committee.json';
-import CorporateResolutionDefinition from './state-machines/corporate-resolution.json';
-import CorporateProxyDefinition from './state-machines/corporate-proxy.json';
-import CorporateSecuritiesDefinition from './state-machines/corporate-securities.json';
-import CorporateComplianceDefinition from './state-machines/corporate-compliance.json';
-/**
- * Corporate governance state machine definitions.
- */
-export const CORPORATE_DEFINITIONS = {
-    Entity: CorporateEntityDefinition,
-    Board: CorporateBoardDefinition,
-    Shareholders: CorporateShareholdersDefinition,
-    Officers: CorporateOfficersDefinition,
-    Bylaws: CorporateBylawsDefinition,
-    Committee: CorporateCommitteeDefinition,
-    Resolution: CorporateResolutionDefinition,
-    Proxy: CorporateProxyDefinition,
-    Securities: CorporateSecuritiesDefinition,
-    Compliance: CorporateComplianceDefinition,
-};

package/dist/esm/apps/governance/types.js

@@ -1,35 +0,0 @@
-/**
- * Governance & DAO Types
- *
- * TypeScript types matching the JSON Logic state machine definitions
- * in ottochain/docs/trust-graph/state-machines/dao/
- *
- * @packageDocumentation
- */
-// =============================================================================
-// Helpers
-// =============================================================================
-/**
- * Type guard for SingleOwnerDAO
- */
-export function isSingleOwnerDAO(state) {
-    return state.schema === 'SingleOwnerDAO';
-}
-/**
- * Type guard for MultisigDAO
- */
-export function isMultisigDAO(state) {
-    return state.schema === 'MultisigDAO';
-}
-/**
- * Type guard for TokenDAO
- */
-export function isTokenDAO(state) {
-    return state.schema === 'TokenDAO';
-}
-/**
- * Type guard for ThresholdDAO
- */
-export function isThresholdDAO(state) {
-    return state.schema === 'ThresholdDAO';
-}

package/dist/esm/apps/identity/types.js

@@ -1,50 +0,0 @@
-/**
- * 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';
-// ---------------------------------------------------------------------------
-// Configuration Defaults
-// ---------------------------------------------------------------------------
-/**
- * Default reputation configuration for agent identity
- */
-export const DEFAULT_REPUTATION_CONFIG = {
-    baseReputation: 10,
-    completionDelta: 5,
-    vouchDelta: 2,
-    violationDelta: -10,
-    behavioralDelta: 3,
-    minReputation: 0,
-    challengeThreshold: 5,
-};
-// ---------------------------------------------------------------------------
-// State Machine Transitions
-// ---------------------------------------------------------------------------
-/**
- * Valid transitions for each agent state
- */
-export const AGENT_TRANSITIONS = {
-    [AgentState.UNSPECIFIED]: [],
-    [AgentState.REGISTERED]: ['activate', 'withdraw'],
-    [AgentState.ACTIVE]: ['challenge', 'withdraw'],
-    [AgentState.CHALLENGED]: ['uphold_challenge', 'dismiss_challenge'],
-    [AgentState.SUSPENDED]: ['begin_probation'],
-    [AgentState.PROBATION]: ['complete_probation'],
-    [AgentState.WITHDRAWN]: [], // Terminal state
-};
-/**
- * Reputation delta by attestation type
- */
-export const ATTESTATION_DELTAS = {
-    [AttestationType.UNSPECIFIED]: 0,
-    [AttestationType.COMPLETION]: 5,
-    [AttestationType.VOUCH]: 2,
-    [AttestationType.VIOLATION]: -10,
-    [AttestationType.BEHAVIORAL]: 3,
-};

package/dist/esm/apps/markets/types.js

@@ -1,206 +0,0 @@
-/**
- * Markets Application Types
- *
- * Constants, types, and utilities for the Markets application on OttoChain.
- *
- * Core types (MarketType, MarketState, Market, Commitment, Resolution) are
- * exported from proto-generated types in index.ts.
- *
- * @packageDocumentation
- */
-import { MarketType, MarketState } from '../../generated/ottochain/apps/markets/v1/market_pb.js';
-/**
- * Commitment direction (for prediction markets)
- */
-export var CommitmentSide;
-(function (CommitmentSide) {
-    CommitmentSide[CommitmentSide["UNSPECIFIED"] = 0] = "UNSPECIFIED";
-    CommitmentSide[CommitmentSide["YES"] = 1] = "YES";
-    CommitmentSide[CommitmentSide["NO"] = 2] = "NO";
-})(CommitmentSide || (CommitmentSide = {}));
-/**
- * Default market configuration
- */
-export const DEFAULT_MARKET_CONFIG = {
-    platformFeePercent: 0.01,
-    creatorFeePercent: 0.02,
-    oracleFeePercent: 0.01,
-    minQuorum: 100n,
-    resolutionWindowEpochs: 24,
-    disputeWindowEpochs: 12,
-    minCommitment: 1n,
-    maxSlippagePercent: 0.05,
-};
-/**
- * Type-specific market configurations
- */
-export const MARKET_TYPE_CONFIGS = {
-    [MarketType.UNSPECIFIED]: {},
-    [MarketType.PREDICTION]: {
-        platformFeePercent: 0.02,
-        oracleFeePercent: 0.02,
-    },
-    [MarketType.AUCTION]: {
-        platformFeePercent: 0.025,
-        creatorFeePercent: 0,
-        oracleFeePercent: 0,
-        minQuorum: 1n,
-    },
-    [MarketType.CROWDFUND]: {
-        platformFeePercent: 0.03,
-        creatorFeePercent: 0,
-        oracleFeePercent: 0,
-        disputeWindowEpochs: 0,
-    },
-    [MarketType.GROUP_BUY]: {
-        platformFeePercent: 0.015,
-        creatorFeePercent: 0.01,
-        oracleFeePercent: 0,
-    },
-};
-// ---------------------------------------------------------------------------
-// State Machine Transitions
-// ---------------------------------------------------------------------------
-/**
- * Valid transitions for each market state (aligned with proto MarketState enum)
- */
-export const MARKET_TRANSITIONS = {
-    [MarketState.UNSPECIFIED]: [],
-    [MarketState.PROPOSED]: ['open', 'cancel'],
-    [MarketState.OPEN]: ['close', 'cancel', 'commit'],
-    [MarketState.CLOSED]: ['submit_resolution', 'refund'],
-    [MarketState.RESOLVING]: ['submit_resolution', 'finalize', 'refund'],
-    [MarketState.SETTLED]: ['claim'], // Terminal (only claims allowed)
-    [MarketState.REFUNDED]: [], // Terminal state
-    [MarketState.CANCELLED]: [], // Terminal state
-};
-/**
- * Check if a market state is terminal
- */
-export function isTerminalMarketState(state) {
-    return [
-        MarketState.SETTLED,
-        MarketState.REFUNDED,
-        MarketState.CANCELLED,
-    ].includes(state);
-}
-// ---------------------------------------------------------------------------
-// Commitment Calculations
-// ---------------------------------------------------------------------------
-/**
- * Calculate effective commitment after fees
- *
- * @param amount - Raw commitment amount
- * @param config - Market configuration (uses defaults if not provided)
- * @returns Net commitment amount after platform fees
- */
-export function calculateNetCommitment(amount, config = {}) {
-    const feePercent = config.platformFeePercent ?? DEFAULT_MARKET_CONFIG.platformFeePercent;
-    const feeAmount = (amount * BigInt(Math.floor(feePercent * 10000))) / 10000n;
-    return amount - feeAmount;
-}
-/**
- * Calculate total fees for a commitment
- *
- * @param amount - Commitment amount
- * @param marketType - Type of market for type-specific fees
- * @returns Fee breakdown object
- */
-export function calculateFees(amount, marketType = MarketType.PREDICTION) {
-    const typeConfig = { ...DEFAULT_MARKET_CONFIG, ...MARKET_TYPE_CONFIGS[marketType] };
-    const platform = (amount * BigInt(Math.floor(typeConfig.platformFeePercent * 10000))) / 10000n;
-    const creator = (amount * BigInt(Math.floor(typeConfig.creatorFeePercent * 10000))) / 10000n;
-    const oracle = (amount * BigInt(Math.floor(typeConfig.oracleFeePercent * 10000))) / 10000n;
-    return {
-        platform,
-        creator,
-        oracle,
-        total: platform + creator + oracle,
-    };
-}
-/**
- * Calculate payout for a winning commitment in a prediction market
- *
- * Winner receives: their original + proportional share of losing pool (minus fees)
- *
- * @param shares - Pool and commitment details
- * @param marketType - Type of market for fee calculation
- * @returns Payout amount
- */
-export function calculatePayout(shares, marketType = MarketType.PREDICTION) {
-    if (shares.winningPool === 0n)
-        return 0n;
-    const fees = calculateFees(shares.losingPool, marketType);
-    const distributablePool = shares.losingPool - fees.total;
-    // Proportional share of losing pool
-    const winnings = (distributablePool * shares.userCommitment) / shares.winningPool;
-    // Return original commitment + winnings
-    return shares.userCommitment + winnings;
-}
-/**
- * Calculate refund for cancelled market
- *
- * @param commitment - Original commitment amount
- * @param refundFeePercent - Optional fee retained on refund (default 0)
- * @returns Refund amount
- */
-export function calculateRefund(commitment, refundFeePercent = 0) {
-    const fee = (commitment * BigInt(Math.floor(refundFeePercent * 10000))) / 10000n;
-    return commitment - fee;
-}
-/**
- * Validate a commitment against market rules
- */
-export function validateCommitment(amount, marketState, config = {}) {
-    const minCommitment = config.minCommitment ?? DEFAULT_MARKET_CONFIG.minCommitment;
-    if (marketState !== MarketState.OPEN) {
-        return { valid: false, reason: 'Market is not open for commitments' };
-    }
-    if (amount < minCommitment) {
-        return { valid: false, reason: `Commitment below minimum: ${minCommitment}` };
-    }
-    return { valid: true };
-}
-/**
- * Calculate crowdfund campaign progress
- */
-export function calculateCrowdfundProgress(current, goal) {
-    if (goal === 0n) {
-        return { current, goal, percentComplete: 0, goalReached: false };
-    }
-    const percentComplete = Number((current * 10000n) / goal) / 100;
-    return {
-        current,
-        goal,
-        percentComplete: Math.min(percentComplete, 100),
-        goalReached: current >= goal,
-    };
-}
-/**
- * Calculate applicable discount based on participant count
- */
-export function calculateGroupBuyDiscount(participantCount, tiers) {
-    // Sort tiers descending by minParticipants
-    const sortedTiers = [...tiers].sort((a, b) => b.minParticipants - a.minParticipants);
-    for (const tier of sortedTiers) {
-        if (participantCount >= tier.minParticipants) {
-            return tier.discountPercent;
-        }
-    }
-    return 0;
-}
-// ---------------------------------------------------------------------------
-// Type Guards
-// ---------------------------------------------------------------------------
-/**
- * Check if a value is a valid MarketState
- */
-export function isMarketState(value) {
-    return typeof value === 'number' && value in MarketState;
-}
-/**
- * Check if a value is a valid MarketType
- */
-export function isMarketType(value) {
-    return typeof value === 'number' && value in MarketType;
-}