aaronbassett/compact-core:standard-library

Compact Standard Library

Complete reference for CompactStandardLibrary - the built-in module providing cryptographic functions, utility types, token operations, and time functions.

Import

import { persistentHash, Maybe, mintToken, blockTime } from "CompactStandardLibrary";

Quick Reference

Cryptographic Functions

| Function | Safe? | Purpose | |----------|-------|---------| | persistentCommit(value) | Yes | Create hiding commitment with nonce (cross-transaction stable) | | transientCommit(value) | Yes | Create hiding commitment with nonce (transaction-local) | | persistentHash(domain, value) | No | Domain-separated hash (cross-transaction stable) | | transientHash(domain, value) | No | Domain-separated hash (transaction-local) | | ecAdd(p1, p2) | - | Elliptic curve point addition | | ecMul(scalar, point) | - | Elliptic curve scalar multiplication |

Safe vs Unsafe: Commit functions include a random nonce, making them hiding. Hash functions do not include a nonce - if the input has low entropy, the hash can be brute-forced.

Utility Types

| Type | Purpose | Variants | |------|---------|----------| | Maybe<T> | Optional value | Some(T), None | | Either<L, R> | Result/choice | Left(L), Right(R) |

Token Operations

| Function | Purpose | |----------|---------| | mintToken(info) | Create new tokens | | send(coin, recipient) | Send tokens to address | | receive() | Receive tokens in circuit | | mergeCoin(coins) | Combine multiple coins |

Time Functions

| Function | Purpose | |----------|---------| | blockTime() | Current block timestamp | | blockTimeBefore(time) | Assert current time < time | | blockTimeAfter(time) | Assert current time > time |

Common Patterns

Safe Commitment

import { persistentCommit } from "CompactStandardLibrary";

witness get_secret(): Field;

export circuit commit_secret(): Bytes<32> {
    const secret = get_secret();
    // Safe: commitment hides the secret
    return persistentCommit(secret);
}

Nullifier Generation

import { persistentHash } from "CompactStandardLibrary";

witness get_secret(): Field;

export circuit generate_nullifier(): Bytes<32> {
    const secret = get_secret();
    // Unsafe but intentional: nullifier should be deterministic
    return persistentHash("nullifier", secret);
}

Optional Value Handling

import { Maybe } from "CompactStandardLibrary";

ledger values: Map<Bytes<32>, Field>;

export circuit get_or_default(key: Bytes<32>): Field {
    const result = values.lookup(key);
    return if result is Maybe::Some(v) { v } else { 0 };
}

Time-Locked Action

import { blockTime, blockTimeAfter } from "CompactStandardLibrary";

ledger unlock_time: Cell<Uint<64>>;

export circuit withdraw(): [] {
    // Fails if current block time <= unlock_time
    blockTimeAfter(unlock_time.read());
    // Perform withdrawal...
}

References

• Crypto Functions - Hash, commit, EC operations
• Utility Types - Maybe, Either patterns
• Token Operations - mintToken, send, receive, mergeCoin
• Time Functions - blockTime and time constraints

Examples

• Crypto Patterns - Cryptographic function usage
• Token Contract - Token operations example
• Time-Locked - Time-based logic example