Skip to main content

Orivon standards

Around the strong core part of orivon-runtime, the rest are just standards built on top of it, making up the structure of how these modules works and communicate together in a safe manner

It's the Client job to ensure that the safety and correctness of a standard is correctly applied by modules

Here I will show you some of these standards:

General Orivon Group Modules​

Groups serves to grant permission to work effectively with multiple modules without exposing them directly, while still allowing them to be used together

group.net.dns​

Example modules:
domains.dns.ens
web3.dns.arweave
icann.dns.eu-gov

Requires ->​

  • Module.resolveDomain(domain) | JSON Object

  • Module.supportedDomains() | Array<string>

Provides access to ->​

  • DNS.resolve(domain, retries, fallbacks) | JSON Object
    Resolve a DNS using the first capable module by priority level
    domain: domain to resolve | String
    retries: amount of retries before giving up | Number
    fallbacks: amount of fallbacks with different modules before giving up | Number
    RETURN: JSON Object containing successful module id and DNS Records

  • DNS.setModulePriority(module, level) | void
    Set priority level for a module

  • DNS.getModules() | Array<{module, level}>

  • DNS.isSupported(domain) | Boolean

  • DNS.supportedDomains() | Array<string>

group.net.data-gather​

Example modules:
ipfs.data-gather.tech
web3.data-gather.arweave
torrent.data-gather.utorrent
ethereum.data-gather.orivon
https.data-gather.orivon

Requires ->​

  • Module.gatherFile(domain) | JSON Object

  • Module.supportedGatherings() | Array<string>

Provides access to ->​

  • DG.getFile(path, method, options) | Object{ Stream<bytes> data, bool DDOC }

  • DG.setModulePriority(string, number) | void

  • DG.getModules | Array<{module, level}>

  • DG.supportedMethods | Array<string>

group.net.web3score​

Example modules:
score.web3score.orivon
score.web3score.wowseoweb3

Requires ->​

  • Module.getWeb3Score(string) | JSON Object

Provides access to ->​

  • WS.getScore(string) | JSON Object

  • WS.setModulePriority(string, number) | void

  • WS.getModules | Array<{module, level}>

group.net.connection​

Handles how modules open, manage and close network connections (TCP, UDP, WebSocket etc.)

This group allows modules to use network connections without getting direct OS-level access, keeping the system secure and sandboxed.

To be defined

group.storage​

Handles how modules persist data locally in a sandboxed and secure way.

To be defined

group.io​

Handles how modules interact with input/output clients (browser, CLI etc.), including rendering UI, sending events and receiving user input.

Example sub groups:
group.io.gui
group.io.textual

To be defined

group.crypto.account​

You can look at Accounts as a compatibility layer between a signing method and whatever crypto/system it is compatible with

Some examples of Account modules which could be connected to that group are:
hardware-wallet.crypto.keystone
mnemonic.crypto.orivon
smart-card.crypto.eu-gov

Connected modules exposes getAccountDescriptor() which allows the caller to know what encryption systems that account type supports, so that implementations (like group.crypto.btc0-1 or group.crypto.eth0-1) can know if they are compatible at all in the first place and for what specific operations they are compatible with

For that manner an array of CapabilityDescriptor will be shared by each account type to inform about everything it is capable of and what not.
Such information is going to be used from modules like group.crypto.address-book, group.crypto.btc0-1, group.crypto.eth0-1 etc...

Requires ->​

  • Module.accountTypes() | JSON (CapabilityDescriptor included)

  • Module.createAccount(type, options) | JSON

  • Module.accountList() | Array<account>

  • Module.getAccountDescriptor(accountId) | JSON<[CapabilityDescriptor]>

  • Module.accountOperate(accountId, payload, options) | JSON

  • Module accountGetKey(accountId, path) | bytes

Provides access to ->​

  • Account.accountTypes() | JSON (CapabilityDescriptor and Module Id included)

  • Account.createAccount(moduleId, type, options)

  • Account.accountList() | Array<{account, moduleId}>

  • Account.getAccountDescriptor(moduleId, accountId) | JSON<[CapabilityDescriptor]>

  • Account.accountOperate(moduleId, accountId, payload, options) | JSON

  • Account accountGetKey(moduleId, accountId, path) | bytes

  • Account.setModulePriority(string, number) | void

  • Account.getModules | Array<{module, level}>

group.crypto-impl.{crypto}​

This is the generic standard that all crypto implementation groups must follow (e.g. group.crypto.btc0-1, group.crypto.eth0-1, group.crypto.monero0-1).

Every crypto implementation group exposes the same set of functions, so that higher level groups like group.crypto.address-book only need to know this one standard interface — regardless of which specific crypto is behind it.

The child modules of a crypto implementation group (e.g. bitcoin.crypto.orivon) implement the crypto-specific logic and expose it through this standard interface.

Requires ->​

  • group.crypto.account

  • Module.{crypto}GetDescriptor(accountId) | Array<CryptoDescriptor>
    Returns the capabilities this crypto implementation supports, including allowed derivation paths

  • Module.{crypto}Operate(accountId, payload, options) | JSON
    Used for signing and other crypto operations

  • Module.{crypto}GetKey(accountId, path) | bytes | Error
    Derives a key at the given path — whether the path is valid is determined by the account or the crypto implementation module based on their supported capabilities

Provides access to ->​

  • CRYPTO.getDescriptor(accountId) | Array<CryptoDescriptor>
    Returns the capabilities of this crypto implementation for a given account
    The website uses this to know what derivation paths and operations are available before making any requests

  • CRYPTO.operate(accountId, payload, options) | JSON
    Executes a crypto operation (sign, verify etc.) through the connected account

  • CRYPTO.getKey(accountId, path) | bytes | Error
    Returns a derived key at the given path
    The error is returned by either the account or the crypto implementation if the path is not within their supported range

  • CRYPTO.setModulePriority(module, level) | void

  • CRYPTO.getModules() | Array<{module, level}>

group.crypto-impl.btc0-1​

Implements the group.crypto-impl.{crypto} standard for Bitcoin.

Child modules implement Bitcoin-specific cryptographic operations (ECDSA, Schnorr, PSBT) and expose them through the standard crypto-impl interface.

Example modules:
bitcoin.crypto.orivon
bitcoin.crypto.sparrow

Requires ->​

  • group.crypto.account

  • Module.bitcoinGetDescriptor(accountId) | Array<CryptoDescriptor>
    Must include Bitcoin-compatible capabilities: SECP256K1_SIGN and allowed BIP44/49/84/86 derivation paths

  • Module.bitcoinOperate(accountId, payload, options) | JSON
    Used for ECDSA and Schnorr signing operations

  • Module.bitcoinGetKey(accountId, path) | bytes | Error
    Derives keys at BIP44/49/84/86 paths — error is returned by the account or the module if the path is not supported

Provides access to ->​

Follows the group.crypto-impl.{crypto} standard interface.

Additionally exposes:

  • BTC.buildTransaction(accountId, inputs, outputs, feeRate) | PSBT
    Constructs an unsigned PSBT from the given UTXOs and outputs
    inputs: UTXOs to spend | Array<UTXO>
    outputs: recipients and amounts | Array<{address, value}>
    feeRate: sat/vB | Number

  • BTC.signTransaction(accountId, psbt) | PSBT
    Signs all inputs of a PSBT using the connected account
    RETURN: Finalized PSBT ready for broadcast

group.crypto.address-book​

Manages address lists across all connected crypto implementation groups.
Does not know which specific cryptos exist — only interacts with groups implementing the group.crypto-impl.{crypto} standard.

The website uses AB.getCapabilities() to know what derivation paths and address types are available for a given account and crypto group, before requesting any addresses.

Child modules under address-book implement specific address list strategies. The website decides which address list module to use, or it can use all available ones based on the CapabilityDescriptor.

Example child modules:
bitcoin.address-book.orivon — default Bitcoin address list following BIP44/84/86
vanity-ethereum.address-book.devbob — generates vanity Ethereum addresses

Requires ->​

  • group.crypto.account

  • Module.getAccountDescriptor(accountId) | Array<CapabilityDescriptor>

  • Any group implementing group.crypto-impl.{crypto} standard

Provides access to ->​

  • AB.getAddress(accountId, cryptoGroupId, index) | AddressInfo | Error
    Returns the address at the given index

  • AB.getAvailableCryptoGroups() | Array<string>
    Returns all crypto group IDs currently connected to the address book

  • AB.getAddressListModules(cryptoGroupId) | Array<{moduleId, descriptor}>
    Returns all available address list modules for a given crypto group
    The website can choose which one to use

group.network.btc-0-1​

Standard access functions for interacting with the Bitcoin network. Modules implementing this standard handle the actual network communication (Electrum servers, REST APIs, or direct P2P).

Example modules:
electrum.btc-network.orivon
esplora.btc-network.blockstream
mempool.btc-network.mempool-space

Requires ->​

  • Module.broadcastTransaction(rawHex) | JSON

  • Module.getUTXOs(scriptHash) | Array<UTXO>

  • Module.getTransaction(txid) | JSON

  • Module.estimateFees() | JSON

  • Module.getBlockHeight() | Number

Provides access to ->​

  • BNET.broadcastTransaction(rawHex) | string
    Broadcasts a signed raw transaction to the Bitcoin network
    RETURN: txid on success

  • BNET.getUTXOs(scriptHash) | Array<UTXO>
    Returns unspent outputs for a given script hash
    RETURN: Array<{txid, vout, value, height}>

  • BNET.getTransaction(txid) | JSON
    Returns full transaction data including confirmation status

  • BNET.estimateFees() | JSON
    Returns fee estimates per confirmation target
    RETURN: {fast, standard, economy, minimum} in sat/vB

  • BNET.getBlockHeight() | Number
    Returns the current best block height

  • BNET.subscribeAddress(scriptHash, callback) | Subscription
    Real-time notifications when a script hash receives or spends outputs

  • BNET.setModulePriority(module, level) | void

  • BNET.getModules() | Array<{module, level}>

TODO's:
group.crypto.eth0-1 Effectively interact with group.crypto.account to implement ethereum
group.crypto.view-only-address-book Interact with supported crypto groups to print out a view only address book
group.network.eth-0-1 Implement a standard of access functions to Ethereum Network