Skip to content

Live technical information site. The planned DLT is not live; membership is on ByteShares.dk.

ByteShares.org

Builders

Developers, API & SDK

Planned

What integrating with ByteShares is intended to look like. There is no endpoint to call, no package to install, no key to obtain and no sandbox to register for. Everything below is a model you can review and argue with, not something you can run.

Not live

The developer platform is not operating. Nothing on this page reports real activity, and no operational figures are shown, because no verified operational data source exists yet.

No base URL, hostname, package name or credential appears anywhere on this page. Any that you encounter elsewhere claiming to be ByteShares did not come from us.

Source / verification
Interface drafts; no implementation to verify against
Document version
API contract: not yet assigned
Last reviewed
7 October 2026

Architecture to evidence — reading path

Proposed / Non-operational: identity → scoped authority and rule context → decision outcome → evidence → bounded closure.

eIDspot describes identity/access; governance defines bounded mandates; VPLedger describes proof/evidence/audit relationships; nodes and DLT remain planned. AI City applications are intended consumers of this architecture, not deployed services. Cooperative membership and one-member-one-vote belong to ByteShares.dk; a ProductCo or application does not inherit cooperative authority.

Claim trace
Connects a specific conceptual statement to its source reference and stated limits; it is not an independent verification result.
Document review date
Records a documentation review, not a source acceptance date, legal approval or software release.
Historical documented design
A source- and edition-bounded earlier proposal; not a current parameter, delivered capability or adopted 2026 rule.
Operational evidence
Assessed implementation, test and operating records supporting a specific claim; prose and document versions are not substitutes.

Historical source editions describe earlier designs. Proposed models remain unadopted; the live documentation site is not evidence of a running DLT. Documentation 0.9 RC1, Proposed Canon v0.1 and historical paper editions are separate version contexts. “Last reviewed” records documentation review, not implementation acceptance.

Questions about the documentation

Ask about documented architecture and readiness; answers cite the pages they draw from and do not verify a running platform.

Ask the documentation →

Developer overview

The intended integration surface is narrow on purpose. A client presents identity and authority, submits an intent, and receives a proof object describing what the protocol did and under which rule version. Reads return accepted state and the evidence needed to check it independently.

Proof-first, not record-first

Documented architecture

An integrator's primary artefact is the proof object, not a row in someone's database. Holding the proof is what lets you verify later without asking us.

Interfaces hold no authority

Documented architecture

An API is a convenience over accepted state. If it disagrees with the protocol record, the protocol record is correct.

Conceptual quick-start

  1. 01

    Establish identity

    Obtain a verified identity and the mandate that scopes what you may do. Mechanism not yet specified.

  2. 02

    Describe the intent

    Express the action, its inputs and the authority under which it is taken.

  3. 03

    Submit

    Present the intent with its proofs to an admission surface for rule evaluation.

  4. 04

    Receive a proof object

    Success or refusal both produce a verifiable record of what was evaluated.

  5. 05

    Retain and verify

    Store the proof; verify inclusion against a later epoch snapshot without trusting any interface.

No step above can be performed today. The sequence is published so it can be reviewed before it is implemented.

Authentication and identity model

Intended authentication and authorization concepts for integrators
ConceptIntended behaviourState
Client identityBound to a verified subject, not to an anonymous API key.To be specified
MandateExplicit scope, issuer and validity period for what a client may do.Documented concept
DelegationAn agent may act within a narrower scope than its principal, never wider.Documented concept
SessionShort-lived and non-authoritative; authority always re-checked at evaluation.To be specified
RevocationImmediate effect on subsequent evaluation, with prior proofs remaining valid for their time.To be specified

Proof-object interaction model

Every interaction is expected to resolve to a proof object. Its fields conceptually cover the subject, the authority, the rule version, the inputs committed to, the outcome and the anchoring reference. The exact serialization, schema and hash construction are to be specified and are deliberately not invented here.

Schema
To be specified
Serialization
To be specified
Hash construction
To be specified
Signature scheme
To be specified

Identity, authority and evidence relationships

Proposed / Non-operational — conceptual relationships, not a finalized object schema.

Proposed non-operational object relationships
ConceptRelationship in the documented modelBoundary / requires source
Subject and credentialA subject presents identity or eligibility evidence issued within a defined scope. Identity alone does not authorize an action.Credential format, issuer trust and verification method: TBD / Requires source.
Authority and mandateA mandate links an issuer, subject, permitted scope and validity period. An agent's delegated scope must not exceed its principal's.Mandate serialization and delegation checks: TBD / Requires source.
Intent and inputsAn intended action references the subject, applicable authority and inputs to be evaluated; inputs may be committed without exposing underlying material.Input encoding, commitment construction and admission rules: TBD / Requires source.
Governance and rule versionGovernance establishes the applicable roles, thresholds and rule context; evaluation should reference that context rather than infer authority from a client session.Decision procedures, exception handling and rule-version format remain unspecified.
Outcome and proof objectThe intended evaluation produces evidence linking subject, authority, rule version, committed inputs and outcome, including refusal.No implemented evaluator, final proof schema or error vocabulary is verified.
Proof and snapshotA retained proof's anchoring reference is intended to support inclusion checking against an epoch snapshot.Snapshot format, hash/signature scheme and trust establishment remain unspecified.

Supporting documentation: Identity / eIDspot · Governance Layer · VPLedger.

Conceptual API and explorer surfaces

Planned interaction surfaces and their status
SurfaceIntended purposeStatus
SubmissionPresent an intent with proofs for rule evaluation.Planned; not built
Proof retrievalFetch a proof object by its reference.Planned; not built
Inclusion verificationCheck a record against an epoch snapshot root.Planned; not built
Governance readRead authorized decisions and rule versions.Planned; not built
Public evidence lookupExplorer-style queries over disclosable records.Planned; not built

Surface names describe function. They are not paths, and no path structure is published.

SDK structure

Intended responsibilities

Planned

Proof construction and verification, authority presentation, snapshot inclusion checks, and typed models of protocol objects.

Deliberately out of scope

Planned

Key custody, wallet UI and membership or payment flows. The last of those belongs to ByteShares.dk, not here.

Languages

Planned

Not decided. No package name, registry entry or version is reserved or claimed.

Offline verification

Planned

A stated goal: verification of a retained proof should not require a call to any ByteShares service.

Proposed SDK responsibility map

Proposed / Non-operational — responsibility boundaries only, not library modules or package contracts.

Conceptual SDK responsibilities and existing documentation dependencies
ResponsibilityExisting modelDecision boundary
Authority presentationSubject, credential and mandate chainPresent scoped evidence; key control or a session must not create authority. Encoding and issuer/status checks require specification.
Proof construction and interpretationInputs, authority, rule context and outcomePreserve the intended bindings, including refusal; no finalized schema, hashing or signature profile is assigned.
Snapshot inclusion checkingEpoch closure and authorized decisionsA historical check needs a trusted root and time/rule context; it must not imply current eligibility or evidence truth.
ExclusionsCustody and authorization boundariesNo key custody, wallet UI, cooperative membership/payment or authority issuance is delegated to this conceptual SDK.

Languages, typed representations, packages, verifier source and test vectors remain TBD / Requires source.

Illustrative request and response shapes

Proposed / Non-operational — reading aids only, not JSON fields, endpoint payloads, executable examples or implementation contracts.

Proposed non-operational request shape — conceptual content only
Request conceptIllustrative contentNot yet specified
Identity presentationEvidence of the subject making the request.Credential encoding and issuer validation.
Authority presentationMandate, permitted scope and any narrower delegation relevant to the intent.Mandate format, revocation freshness and authority checks.
Intent and inputsThe action sought and the inputs or commitments evaluated under an applicable rule context.Action vocabulary, serialization and commitment construction.

Proposed / Non-operational response shape — no response is produced by an operating ByteShares DLT service.

Proposed non-operational response shape — conceptual content only
Response conceptIllustrative contentNot yet specified
Evaluation outcomeAcceptance or refusal tied to the rule version considered; refusal should explain the evaluated failure without unrelated disclosure.Outcome vocabulary, refusal codes and disclosure rules.
Proof contextSubject, authority, committed inputs and applicable rule version associated with the result.Final schema and signature scheme.
Anchoring referenceA reference intended to connect retained evidence to a later epoch snapshot for inclusion verification.Reference format, snapshot construction and proof encoding.

These shapes restate the existing proof-object model; they assign no field names, types, cardinalities or wire format. All unspecified details are TBD / Requires source.

Offline-verification intent and limits

Proposed / Non-operational — no verifier, test vector or successful offline result is claimed.

The documented goal is to retain a proof and check its inclusion against an epoch snapshot without calling a ByteShares service. This requires more than retaining an interface response.

  1. Retain the proof context: subject, authority, rule version, input commitments, outcome and anchoring reference.
  2. Obtain the relevant snapshot and inclusion material. Their format and the method of establishing a trusted snapshot are TBD / Requires source.
  3. Check the intended binding and inclusion under specified hashing and signature rules. Those rules and a verifier implementation are not supplied.
  4. Interpret the result within its historical rule and authority context. Inclusion alone does not prove legal title, underlying evidence truth, current authorization or a live network.

Revocation and time semantics need a specification: an offline historical check must not be represented as proof of current eligibility. See snapshot and evidence boundaries, credential lifecycle and security requirements.

Integration lifecycle

  1. 01

    Review

    Read the documented model and raise gaps while it is still cheap to change.

  2. 02

    Eligibility

    Integration requires an authorized mandate, granted through governance rather than self-service.

  3. 03

    Conformance

    An integration demonstrates that it constructs and verifies proofs correctly.

  4. 04

    Operation

    Integrations run against a published contract version with a stated support window.

  5. 05

    Change

    Contract changes follow the versioning policy below, with notice before removal.

Error and status conventions

A refusal is expected to be as verifiable as an acceptance: it should state the rule version applied and why the evaluation failed, without disclosing unrelated data. Concrete codes, categories and payload shapes are to be specified.

Versioning and deprecation policy

Intended versioning policy framework
ElementIntended policyState
Contract versioningExplicit version on every interface and proof object.Framework agreed; scheme not assigned
Breaking changeNew version rather than mutation of an existing one.Framework agreed
Deprecation noticeAnnounced period before removal, published in advance.Period not set
Rule-version referenceEvery proof names the rule version under which it was evaluated.Documented concept
Historic verificationOld proofs remain verifiable after the contract moves on.Requirement; unimplemented

Proposed refusal and change-policy boundaries

Proposed / Non-operational — policy framework, not assigned codes, versions or support commitments.

  • A refusal should identify the evaluated rule context and failure without unrelated disclosure; a transport response alone is not the intended proof object.
  • A breaking contract change should introduce a new version rather than rewrite the meaning of retained proofs. Historical verification still needs the original rule and authority context.
  • Documentation 0.9 RC1 is not an API, SDK, ledger or specification version. Software and specification versioning remain prospective and separately assigned.
  • Error vocabulary, contract version scheme, compatibility rules and deprecation/support periods require a source specification or owner decision; no numeric period is implied.
Separate software and specification versioning

Source code

Awaiting GitHub connection. No repository is linked, named or implied, and the VPLedger source provenance audit is still open.

Publication follows a twelve-gate readiness process covering source inventory, integrity hashes, provenance classification, exclusion of sensitive material, licensing review, canonical repository mapping, build baseline, version baseline, documentation baseline, owner approval, import verification and future source/operational acceptance. The documentation site domain and public indexing are already active. A developer-docs repository is proposed for this material, and an sdk repository only if a distinct verified SDK codebase is found. Both remain proposals with no source accepted.

Open questions / evidence required

Proposed / Non-operational — review questions, not decisions or implementation contracts.

When can conceptual shapes become contracts?
TBD / Requires source: Approved proof/credential/mandate schemas, encoding, hashing/signature, error vocabulary and version/support policy; current shapes assign no wire fields or types.
What is needed for an offline SDK verifier?
TBD / Requires source: Trusted-snapshot establishment, inclusion and historical authority/time specifications, verifier source and test vectors; no package, language or successful result is claimed.
Documentation-gap audit and evidence boundaries

Evidence register

Each statement on this page is tracked against a source. A claim without a verified source is never presented as fact.

Claims on this page and the verification state of their sources
ClaimSource typeVerificationNote
Interaction model, surfaces and lifecycleInterface draftsSource claimed, not yet verifiedRelationships, illustrative shapes and offline-verification intent restate existing identity, governance and VPLedger documentation. No implementation checked and no verification state upgraded.
Proof-object schema, error codes and SDK contentsSpecificationNo source on fileConceptual shapes are not finalized schemas. Serialization, hashing, signature schemes, revocation semantics, trust establishment and verifier test vectors require source.
Endpoints, packages, keys or sandboxesRunning serviceNo source on fileNone exist; none are published.