API
Application Programming Interface
The Yuzo API provides external systems with structured access to metaprotocol-derived state and programmable execution primitives expressed through Bitcoin inscriptions.
Interfaces support:
Read access to token balances and contract storage reconstructed from ordered inscription data
Write access for constructing and submitting execution instructions targeting programmable module contracts
Query access to confirmed transaction outcomes and resulting state transitions
These APIs expose infrastructure capabilities required to interact with BRC-20 assets and programmable contracts. They do not perform execution, custody assets, or manage financial activity on behalf of users. Execution and state mutation occur through confirmed Bitcoin transactions and are deterministically interpreted by indexers.
Data Surfaces
Exposed endpoints provide access to protocol-derived state reconstructed from confirmed inscriptions and execution outputs.
Available data includes:
Inscription-ordered token balances and transfer history
Contract storage state derived from programmable execution
Vault settlement metrics, including LP position balances and reward distribution outcomes
Execution logs and emitted contract events
Issuance, redemption, and adjustment records for tokenized instruments
All reported values are deterministically derived from block-ordered inscription data and execution traces, enabling reproducible observability across indexers.
Execution Interfaces
Execution endpoints allow external platforms to initiate programmable actions within the BRC-20 Programmable Module by constructing inscription-compatible payloads.
Supported interfaces:
Contract deployment request construction
ABI-encoded contract call submission
Token deposit instruction formatting
Withdrawal initiation requests
Multi-step execution batching across sequential operations
These APIs assemble execution payloads in the appropriate protocol namespace (e.g. brc20-prog) for commit–reveal inscription. Upon confirmation, programmable module indexers interpret the inscribed instructions to perform deterministic contract execution and update canonical state.
Settlement Synchronization
Settlement synchronization endpoints provide downstream systems with timely alignment between confirmed onchain outcomes and offchain financial records.
Interfaces support:
Block confirmation tracking for executed inscriptions
Confirmation-depth monitoring for economic finality assumptions
Share registry reconciliation against confirmed issuance or redemption events
Token supply adjustment signaling following settlement
Protocol-derived state changes are exposed only after block confirmation, allowing administrators and external systems to update accounting records, registries, and reporting layers in accordance with finalized settlement data.
External Data Ingestion
External data ingestion endpoints enable programmable contracts to reference offchain inputs required for tokenized RWAs and structured financial products.
Supported inputs include:
NAV and valuation feeds
Pricing inputs for underlying reference assets
Eligibility attestations for issuance or redemption constraints
Risk parameter updates for vault or lending logic
These inputs are submitted as signed data payloads and consumed by contracts operating within the BRC-20 Programmable Module. Validation and interpretation occur at the programmable execution level. External data is not enforced by Bitcoin consensus and does not alter base-layer transaction validity.
Indexer Integration
Indexers are required to interpret inscription data and derive programmable state consistently across execution environments.
Integration requirements include:
Replay of confirmed inscriptions in block order
Adherence to the BRC-20 Programmable Module runtime specification
Deterministic contract execution and storage mutation
Event and log emission derived from execution outcomes
When these requirements are met, independently operated indexers converge on a canonical contract state through deterministic replay. This enables reproducible execution results and interoperable state derivation across runtime implementations.
Last updated