miniledger 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,702 @@
+import { EventEmitter } from 'node:events';
+import pino from 'pino';
+import Database from 'better-sqlite3';
+import WebSocket from 'ws';
+
+type HexString = string;
+declare enum TxType {
+    StateSet = "state:set",
+    StateDelete = "state:delete",
+    ContractDeploy = "contract:deploy",
+    ContractInvoke = "contract:invoke",
+    GovernancePropose = "governance:propose",
+    GovernanceVote = "governance:vote"
+}
+interface StateSetPayload {
+    kind: "state:set";
+    key: string;
+    value: unknown;
+}
+interface StateDeletePayload {
+    kind: "state:delete";
+    key: string;
+}
+interface ContractDeployPayload {
+    kind: "contract:deploy";
+    name: string;
+    version: string;
+    code: string;
+}
+interface ContractInvokePayload {
+    kind: "contract:invoke";
+    contract: string;
+    method: string;
+    args: unknown[];
+}
+interface GovernanceProposePayload {
+    kind: "governance:propose";
+    title: string;
+    description: string;
+    action: Record<string, unknown>;
+}
+interface GovernanceVotePayload {
+    kind: "governance:vote";
+    proposalId: string;
+    vote: boolean;
+}
+type TxPayload = StateSetPayload | StateDeletePayload | ContractDeployPayload | ContractInvokePayload | GovernanceProposePayload | GovernanceVotePayload;
+interface Transaction {
+    hash: HexString;
+    type: TxType;
+    sender: HexString;
+    nonce: number;
+    timestamp: number;
+    payload: TxPayload;
+    signature: HexString;
+}
+interface Block {
+    height: number;
+    hash: HexString;
+    previousHash: HexString;
+    timestamp: number;
+    merkleRoot: HexString;
+    stateRoot: HexString;
+    proposer: HexString;
+    signature: HexString;
+    transactions: Transaction[];
+}
+interface StateEntry {
+    key: string;
+    value: unknown;
+    version: number;
+    updatedAt: number;
+    updatedBy: HexString;
+    blockHeight: number;
+}
+interface PeerInfo {
+    id: string;
+    publicKey: HexString;
+    address: string;
+    orgId: string;
+    role: "validator" | "observer";
+    status: "connected" | "disconnected" | "syncing";
+    lastSeen: number;
+    chainHeight: number;
+}
+interface NodeIdentity {
+    publicKey: HexString;
+    nodeId: string;
+    orgId: string;
+    name: string;
+    role: "admin" | "member" | "observer";
+    createdAt: number;
+}
+interface NodeStatus {
+    nodeId: string;
+    publicKey: HexString;
+    chainHeight: number;
+    latestBlockHash: HexString;
+    peerCount: number;
+    txPoolSize: number;
+    uptime: number;
+    version: number;
+}
+
+declare class MiniLedgerDB {
+    private db;
+    constructor(dbPath: string);
+    /** Run all pending migrations. */
+    migrate(): void;
+    /** Get the underlying better-sqlite3 Database instance. */
+    raw(): Database.Database;
+    close(): void;
+}
+
+declare class BlockStore {
+    private q;
+    constructor(db: Database.Database);
+    insert(block: Block): void;
+    getByHeight(height: number): Block | null;
+    getByHash(hash: string): Block | null;
+    getLatest(): Block | null;
+    getRange(fromHeight: number, toHeight: number): Block[];
+    getHeight(): number;
+}
+
+declare class StateStore {
+    private q;
+    private db;
+    constructor(db: Database.Database);
+    get(key: string): StateEntry | null;
+    set(key: string, value: unknown, updatedBy: string, blockHeight: number): void;
+    delete(key: string): boolean;
+    /** Execute a read-only SQL query against the world_state table. */
+    query(sql: string, params?: unknown[]): Record<string, unknown>[];
+    /** Compute a hash of the entire world state (for stateRoot). */
+    computeStateRoot(): string;
+    count(): number;
+}
+
+declare class TxStore {
+    private q;
+    constructor(db: Database.Database);
+    getByHash(hash: string): Transaction | null;
+    getBySender(sender: string, limit?: number): Transaction[];
+    /** Add a transaction to the pending pool. */
+    addToPending(tx: Transaction): void;
+    /** Get all pending transactions, ordered by received time. */
+    getPending(limit?: number): Transaction[];
+    /** Remove transactions from the pending pool (after inclusion in a block). */
+    removePending(hashes: string[]): void;
+    pendingCount(): number;
+    /** Get the next nonce for a sender. */
+    getNextNonce(sender: string): number;
+    /** Update the nonce tracker for a sender. */
+    updateNonce(sender: string, nonce: number): void;
+}
+
+interface MiniLedgerConfig {
+    dataDir: string;
+    node: {
+        name: string;
+        orgId: string;
+        role: "validator" | "observer";
+    };
+    network: {
+        listenAddress: string;
+        p2pPort: number;
+        apiPort: number;
+        peers: string[];
+        maxPeers: number;
+    };
+    consensus: {
+        algorithm: "raft" | "solo";
+        blockTimeMs: number;
+        maxTxPerBlock: number;
+    };
+    api: {
+        enabled: boolean;
+        cors: boolean;
+    };
+    logging: {
+        level: "debug" | "info" | "warn" | "error";
+    };
+}
+
+declare enum MessageType {
+    Handshake = "HANDSHAKE",
+    HandshakeAck = "HANDSHAKE_ACK",
+    BlockAnnounce = "BLOCK_ANNOUNCE",
+    BlockRequest = "BLOCK_REQUEST",
+    BlockResponse = "BLOCK_RESPONSE",
+    TxBroadcast = "TX_BROADCAST",
+    TxForward = "TX_FORWARD",// Forward tx to leader
+    ConsensusRequestVote = "CONSENSUS_REQUEST_VOTE",
+    ConsensusRequestVoteReply = "CONSENSUS_REQUEST_VOTE_REPLY",
+    ConsensusAppendEntries = "CONSENSUS_APPEND_ENTRIES",
+    ConsensusAppendEntriesReply = "CONSENSUS_APPEND_ENTRIES_REPLY",
+    SyncRequest = "SYNC_REQUEST",
+    SyncResponse = "SYNC_RESPONSE",
+    PeerList = "PEER_LIST",
+    Ping = "PING",
+    Pong = "PONG"
+}
+interface MessageEnvelope<T = unknown> {
+    version: number;
+    type: MessageType;
+    from: string;
+    timestamp: number;
+    payload: T;
+}
+
+interface PeerState {
+    nodeId: string;
+    publicKey: HexString;
+    orgId: string;
+    address: string;
+    chainHeight: number;
+    status: "connecting" | "connected" | "disconnected";
+    lastSeen: number;
+    isInbound: boolean;
+}
+declare class Peer {
+    readonly nodeId: string;
+    publicKey: HexString;
+    orgId: string;
+    address: string;
+    chainHeight: number;
+    status: "connecting" | "connected" | "disconnected";
+    lastSeen: number;
+    isInbound: boolean;
+    private ws;
+    constructor(ws: WebSocket, info: Partial<PeerState> & {
+        nodeId: string;
+        isInbound: boolean;
+    });
+    send(msg: MessageEnvelope): void;
+    close(): void;
+    getSocket(): WebSocket;
+    updateSeen(): void;
+    toInfo(): PeerState;
+}
+
+type MessageHandler = (msg: MessageEnvelope, peer: Peer) => void | Promise<void>;
+/**
+ * Routes incoming messages to registered handlers by message type.
+ */
+declare class MessageRouter {
+    private handlers;
+    on(type: MessageType, handler: MessageHandler): void;
+    off(type: MessageType, handler: MessageHandler): void;
+    dispatch(msg: MessageEnvelope, peer: Peer): Promise<void>;
+}
+
+interface PeerManagerOptions {
+    nodeId: string;
+    publicKey: HexString;
+    orgId: string;
+    p2pPort: number;
+    listenAddress: string;
+    log: pino.Logger;
+    getChainHeight: () => number;
+}
+declare class PeerManager extends EventEmitter {
+    readonly router: MessageRouter;
+    private server;
+    private client;
+    private peers;
+    private opts;
+    private healthTimer;
+    constructor(opts: PeerManagerOptions);
+    start(): Promise<void>;
+    stop(): void;
+    /** Connect to a peer by address (ws://host:port). */
+    connectTo(address: string): void;
+    /** Broadcast a message to all connected peers. */
+    broadcast(msg: MessageEnvelope): void;
+    /** Send a message to a specific peer by nodeId. */
+    sendTo(nodeId: string, msg: MessageEnvelope): void;
+    /** Send to leader or a specific peer. */
+    sendToPeer(peer: Peer, msg: MessageEnvelope): void;
+    getPeer(nodeId: string): Peer | undefined;
+    getConnectedPeers(): Peer[];
+    getPeerStates(): PeerState[];
+    getPeerCount(): number;
+    /** Get all known node IDs (for Raft voter list). */
+    getKnownNodeIds(): string[];
+    private onRawPeerConnected;
+    private onRawPeerDisconnected;
+    private sendHandshake;
+    private handleHandshake;
+    private handleHandshakeAck;
+    private handlePing;
+    private handlePong;
+    private handlePeerList;
+    private sharePeerList;
+    private pingAll;
+}
+
+declare enum RaftRole {
+    Follower = "follower",
+    Candidate = "candidate",
+    Leader = "leader"
+}
+interface ConsensusState {
+    role: RaftRole;
+    term: number;
+    leaderId: string | null;
+    votedFor: string | null;
+    commitIndex: number;
+}
+/**
+ * Interface that consensus implementations must satisfy.
+ * The node orchestrator interacts with consensus through this interface.
+ */
+interface IConsensus {
+    /** Start the consensus engine. */
+    start(): void;
+    /** Stop the consensus engine. */
+    stop(): void;
+    /** Check if this node is the current leader. */
+    isLeader(): boolean;
+    /** Get the current leader's node ID (if known). */
+    getLeaderId(): string | null;
+    /** Get current consensus state for status reporting. */
+    getState(): ConsensusState;
+    /** Propose a block with pending transactions. Called by the node when it's time to produce a block. */
+    proposeBlock(block: Block): void;
+    /** Handle a received block from consensus (called when a committed entry needs to be applied). */
+    onBlockCommitted: ((block: Block) => void) | null;
+    /** Handle transaction received — if leader, include in next block; if follower, forward to leader. */
+    onTransactionReceived: ((tx: Transaction) => void) | null;
+}
+
+interface RaftNodeOptions {
+    nodeId: string;
+    peerManager: PeerManager;
+    log: pino.Logger;
+    blockTimeMs: number;
+}
+/**
+ * Raft consensus implementation.
+ *
+ * Key simplification: Raft log entries ARE block proposals.
+ * A committed entry directly becomes a finalized block.
+ */
+declare class RaftNode extends EventEmitter implements IConsensus {
+    private opts;
+    private role;
+    private currentTerm;
+    private votedFor;
+    private leaderId;
+    private raftLog;
+    private commitIndex;
+    private lastApplied;
+    private nextIndex;
+    private matchIndex;
+    private timer;
+    private blockProposalTimer;
+    onBlockCommitted: ((block: Block) => void) | null;
+    onTransactionReceived: ((tx: Transaction) => void) | null;
+    constructor(opts: RaftNodeOptions);
+    start(): void;
+    stop(): void;
+    isLeader(): boolean;
+    getLeaderId(): string | null;
+    getState(): ConsensusState;
+    /** Called by the node to propose a block (only works when leader). */
+    proposeBlock(block: Block): void;
+    /** Forward a transaction to the current leader. */
+    forwardToLeader(tx: Transaction): void;
+    private startElection;
+    private _voteCallback;
+    private becomeLeader;
+    private stepDown;
+    private handleRequestVote;
+    private handleRequestVoteReply;
+    private isLogUpToDate;
+    private sendHeartbeats;
+    private sendAppendEntries;
+    private handleAppendEntries;
+    private sendAppendEntriesReply;
+    private handleAppendEntriesReply;
+    private advanceCommitIndex;
+    private applyCommitted;
+}
+
+interface ContractInstance {
+    name: string;
+    version: string;
+    deployedAt: number;
+    deployedBy: string;
+}
+/**
+ * The context object passed to contract functions.
+ * Contracts interact with state exclusively through this interface.
+ */
+interface ContractContext {
+    /** Read a value from world state. */
+    get(key: string): unknown | null;
+    /** Write a value to world state. */
+    set(key: string, value: unknown): void;
+    /** Delete a key from world state. */
+    del(key: string): void;
+    /** Get the sender (public key) of the current transaction. */
+    readonly sender: string;
+    /** Get the current block height. */
+    readonly blockHeight: number;
+    /** Get current timestamp. */
+    readonly timestamp: number;
+    /** Emit a log entry (stored in tx receipt). */
+    log(message: string): void;
+}
+type ContractFunction = (ctx: ContractContext, ...args: unknown[]) => unknown;
+interface ContractModule {
+    [methodName: string]: ContractFunction;
+}
+
+interface ContextOptions {
+    stateStore: StateStore;
+    sender: string;
+    blockHeight: number;
+    timestamp: number;
+}
+/**
+ * Creates a ContractContext that contracts use to interact with the ledger.
+ * All state mutations go through the StateStore.
+ */
+declare function createContractContext(opts: ContextOptions): ContractContext & {
+    getLogs(): string[];
+};
+
+/**
+ * Compile contract source code into a callable module.
+ *
+ * Contracts are JavaScript/TypeScript functions. The source code should export
+ * methods as properties of a returned object. Example:
+ *
+ * ```
+ * return {
+ *   init(ctx) { ctx.set("counter", 0); },
+ *   increment(ctx, amount) {
+ *     const val = ctx.get("counter") || 0;
+ *     ctx.set("counter", val + amount);
+ *     return val + amount;
+ *   }
+ * }
+ * ```
+ */
+declare function compileContract(source: string): ContractModule;
+/**
+ * Execute a contract method with a context and arguments.
+ * Enforces a timeout to prevent infinite loops.
+ */
+declare function executeContract(mod: ContractModule, method: string, ctx: ContractContext, args?: unknown[]): unknown;
+
+/**
+ * Manages deployed contracts. Contract metadata and code are stored in world state
+ * with reserved key prefixes.
+ */
+declare class ContractRegistry {
+    private compiled;
+    private stateStore;
+    constructor(stateStore: StateStore);
+    /** Deploy a new contract or upgrade an existing one. */
+    deploy(name: string, version: string, code: string, deployedBy: string, blockHeight: number): void;
+    /** Get a compiled contract module, loading from state if needed. */
+    getModule(name: string): ContractModule | null;
+    /** Get contract metadata. */
+    getInstance(name: string): ContractInstance | null;
+    /** Invoke a method on a deployed contract. */
+    invoke(contractName: string, method: string, ctx: ContractContext, args?: unknown[]): unknown;
+    /** List all deployed contracts. */
+    listContracts(): ContractInstance[];
+    /** Clear compiled cache (useful after chain reorg). */
+    clearCache(): void;
+}
+
+/**
+ * Built-in contract: token transfer.
+ *
+ * State keys: "balance:<address>" -> number
+ */
+declare const TRANSFER_CONTRACT = "\nreturn {\n  init(ctx, initialBalance) {\n    ctx.set(\"balance:\" + ctx.sender, initialBalance || 0);\n    ctx.log(\"Account initialized with balance: \" + (initialBalance || 0));\n  },\n\n  mint(ctx, amount) {\n    if (typeof amount !== \"number\" || amount <= 0) throw new Error(\"Invalid amount\");\n    const key = \"balance:\" + ctx.sender;\n    const current = ctx.get(key) || 0;\n    ctx.set(key, current + amount);\n    ctx.log(\"Minted \" + amount + \" to \" + ctx.sender);\n    return current + amount;\n  },\n\n  transfer(ctx, to, amount) {\n    if (typeof amount !== \"number\" || amount <= 0) throw new Error(\"Invalid amount\");\n    if (!to) throw new Error(\"Recipient required\");\n\n    const fromKey = \"balance:\" + ctx.sender;\n    const toKey = \"balance:\" + to;\n\n    const fromBalance = ctx.get(fromKey) || 0;\n    if (fromBalance < amount) throw new Error(\"Insufficient balance\");\n\n    const toBalance = ctx.get(toKey) || 0;\n    ctx.set(fromKey, fromBalance - amount);\n    ctx.set(toKey, toBalance + amount);\n    ctx.log(\"Transfer \" + amount + \" from \" + ctx.sender + \" to \" + to);\n  },\n\n  balance(ctx, address) {\n    const key = \"balance:\" + (address || ctx.sender);\n    return ctx.get(key) || 0;\n  }\n}\n";
+/**
+ * Built-in contract: simple key-value store with ownership.
+ */
+declare const KV_STORE_CONTRACT = "\nreturn {\n  set(ctx, key, value) {\n    const fullKey = \"kv:\" + key;\n    const existing = ctx.get(fullKey + \":owner\");\n    if (existing && existing !== ctx.sender) throw new Error(\"Not owner of key: \" + key);\n    ctx.set(fullKey, value);\n    ctx.set(fullKey + \":owner\", ctx.sender);\n  },\n\n  get(ctx, key) {\n    return ctx.get(\"kv:\" + key);\n  },\n\n  del(ctx, key) {\n    const owner = ctx.get(\"kv:\" + key + \":owner\");\n    if (owner && owner !== ctx.sender) throw new Error(\"Not owner of key: \" + key);\n    ctx.del(\"kv:\" + key);\n    ctx.del(\"kv:\" + key + \":owner\");\n  }\n}\n";
+
+declare enum ProposalType {
+    AddPeer = "add-peer",
+    RemovePeer = "remove-peer",
+    UpdateConfig = "update-config",
+    UpgradeContract = "upgrade-contract",
+    Custom = "custom"
+}
+declare enum ProposalStatus {
+    Active = "active",
+    Approved = "approved",
+    Rejected = "rejected",
+    Expired = "expired"
+}
+interface Proposal {
+    id: string;
+    type: ProposalType;
+    title: string;
+    description: string;
+    proposer: string;
+    action: Record<string, unknown>;
+    status: ProposalStatus;
+    createdAt: number;
+    expiresAt: number;
+    votes: Record<string, boolean>;
+}
+
+/**
+ * Governor: manages the lifecycle of governance proposals.
+ * Proposals are stored in world state with a reserved key prefix.
+ */
+declare class Governor {
+    private stateStore;
+    constructor(stateStore: StateStore);
+    /** Create and store a new proposal. */
+    propose(opts: {
+        type: ProposalType;
+        title: string;
+        description: string;
+        proposer: string;
+        action: Record<string, unknown>;
+        blockHeight: number;
+        votingPeriodMs?: number;
+    }): Proposal;
+    /** Cast a vote on a proposal. */
+    vote(proposalId: string, voter: string, approve: boolean, blockHeight: number): Proposal;
+    /**
+     * Evaluate a proposal: check if it should be approved, rejected, or expired.
+     * Returns the action to execute if approved, null otherwise.
+     */
+    evaluate(proposalId: string, totalVoters: number, blockHeight: number): {
+        status: ProposalStatus;
+        action: Record<string, unknown> | null;
+    };
+    /** Get a proposal by ID. */
+    getProposal(proposalId: string): Proposal | null;
+    /** List all proposals. */
+    listProposals(): Proposal[];
+}
+
+interface CreateNodeOptions {
+    dataDir?: string;
+    config?: Partial<MiniLedgerConfig>;
+}
+declare class MiniLedgerNode extends EventEmitter {
+    readonly config: MiniLedgerConfig;
+    readonly log: pino.Logger;
+    private db;
+    private blockStore;
+    private stateStore;
+    private txStore;
+    private chain;
+    private keyPair;
+    private nodeId;
+    private blockTimer;
+    private peerManager;
+    private blockSync;
+    private raft;
+    private raftBlockTimer;
+    private contractRegistry;
+    private governor;
+    private startedAt;
+    private running;
+    constructor(config: MiniLedgerConfig);
+    /** Create a new MiniLedgerNode with optional overrides. */
+    static create(options?: CreateNodeOptions): Promise<MiniLedgerNode>;
+    /** Initialize the node: open DB, load or create identity, restore chain. */
+    init(): Promise<void>;
+    /** Start the node: begin producing blocks and serving API. */
+    start(): Promise<void>;
+    /** Stop the node. */
+    stop(): Promise<void>;
+    private startNetworking;
+    private startRaftConsensus;
+    private handleBlockAnnounce;
+    private handleTxBroadcast;
+    /** Apply a block received from network/consensus. */
+    private applyReceivedBlock;
+    /** Submit a transaction to the node. */
+    submit(params: {
+        type?: TxType;
+        key?: string;
+        value?: unknown;
+        payload?: Transaction["payload"];
+    }): Promise<Transaction>;
+    /** Produce a block in solo mode. */
+    private produceBlock;
+    /** Produce a block as Raft leader — propose it through consensus. */
+    private produceRaftBlock;
+    /** Apply a single transaction to the world state. */
+    private applyTransaction;
+    query(sql: string, params?: unknown[]): Promise<Record<string, unknown>[]>;
+    getState(key: string): Promise<StateEntry | null>;
+    getBlock(height: number): Promise<Block | null>;
+    getLatestBlock(): Promise<Block | null>;
+    getTransaction(hash: string): Promise<Transaction | null>;
+    getStatus(): NodeStatus;
+    getPublicKey(): string;
+    getNodeId(): string;
+    getStores(): {
+        blocks: BlockStore;
+        state: StateStore;
+        txs: TxStore;
+    };
+    getDatabase(): MiniLedgerDB;
+    getPeerManager(): PeerManager | null;
+    getRaft(): RaftNode | null;
+    getContractRegistry(): ContractRegistry;
+    getGovernor(): Governor;
+    isRunning(): boolean;
+}
+
+interface KeyPair {
+    publicKey: string;
+    privateKey: string;
+}
+/** Generate a new Ed25519 keypair. */
+declare function generateKeyPair(): KeyPair;
+
+/** Sign a message (hex string or raw string) with a private key. Returns hex signature. */
+declare function sign(message: string, privateKeyHex: string): string;
+/** Verify a signature against a message and public key. */
+declare function verify(message: string, signatureHex: string, publicKeyHex: string): boolean;
+
+/**
+ * In-memory chain manager. Tracks the current chain tip and validates new blocks.
+ * Backed by a storage layer for persistence.
+ */
+declare class Chain {
+    private tip;
+    private height;
+    /** Initialize chain with genesis block or restore from latest block. */
+    init(latestBlock?: Block): void;
+    /** Create and return a genesis block. */
+    createGenesis(proposer: HexString): Block;
+    /** Propose a new block with the given transactions. Returns unsigned block. */
+    proposeBlock(transactions: Transaction[], proposer: HexString, stateRoot: HexString): Block;
+    /** Validate and append a block to the chain. */
+    appendBlock(block: Block): void;
+    getTip(): Block | null;
+    getHeight(): number;
+}
+
+interface ACLPolicy {
+    /** Public key of the record owner. */
+    owner: string;
+    /** Public keys that can read this record. Empty = owner only. */
+    readers: string[];
+    /** Public keys that can write this record. Empty = owner only. */
+    writers: string[];
+    /** If true, anyone can read (value is unencrypted). */
+    public: boolean;
+}
+declare function createACL(owner: string, opts?: {
+    readers?: string[];
+    writers?: string[];
+    public?: boolean;
+}): ACLPolicy;
+/** Check if an identity can read a record. */
+declare function canRead(acl: ACLPolicy, publicKey: string): boolean;
+/** Check if an identity can write/update a record. */
+declare function canWrite(acl: ACLPolicy, publicKey: string): boolean;
+
+interface EncryptedRecord {
+    /** The encrypted value (hex). */
+    ciphertext: string;
+    /** Per-recipient encrypted AES keys: publicKey -> encryptedAESKey (hex). */
+    encryptedKeys: Record<string, string>;
+    /** The ACL policy (stored in plaintext for access control). */
+    acl: ACLPolicy;
+    /** The sender's public key (needed for decryption key derivation). */
+    senderPublicKey: string;
+}
+/**
+ * Encrypt a value for a set of authorized readers.
+ * Each reader gets a copy of the AES key encrypted with a pairwise secret
+ * derived from the sender's and reader's public keys.
+ */
+declare function encryptForACL(value: string, acl: ACLPolicy, _senderPrivateKey: string, senderPublicKey?: string): EncryptedRecord;
+/**
+ * Decrypt a record if the reader has access.
+ * Uses the pairwise secret between the sender and reader's public keys.
+ */
+declare function decryptRecord(record: EncryptedRecord, _readerPrivateKey: string, readerPublicKey: string): string | null;
+
+interface GovernancePolicy {
+    /** Minimum quorum percentage (0-100) for proposals to pass. */
+    quorumPercent: number;
+    /** Default voting period in milliseconds. */
+    votingPeriodMs: number;
+    /** Proposal types that any member can create. */
+    allowedProposalTypes: ProposalType[];
+}
+
+export { type ACLPolicy, type Block, Chain, type ContractContext, type ContractInstance, type ContractModule, ContractRegistry, type CreateNodeOptions, type EncryptedRecord, type GovernancePolicy, Governor, type HexString, KV_STORE_CONTRACT, type KeyPair, MiniLedgerNode as MiniLedger, MiniLedgerNode, type NodeIdentity, type NodeStatus, type PeerInfo, type Proposal, ProposalStatus, ProposalType, type StateEntry, TRANSFER_CONTRACT, type Transaction, type TxPayload, TxType, canRead, canWrite, compileContract, createACL, createContractContext, decryptRecord, encryptForACL, executeContract, generateKeyPair, sign, verify };