Particle CS Launch app (opens in a new tab)

Put the checks where the function runs.

Your app knows who signed. Your contract should know what that signer may do — with open-source components for roles, delays and approvals.

Developer quickstart (opens in a new tab)Bloxchain Protocol
Where control breaks today

Access logic lives everywhere except where it counts.

Most applications check permissions before a call reaches the chain. The function that moves value or changes settings often checks far less.

Checks live in the app, not the contract

Permissions are enforced by the backend or the interface. Call the contract another way and they’re gone.

One owner key runs everything

A single owner key controls every administrative function, from fees to upgrades.

Every team rebuilds access control

The same roles-and-approvals logic is written, tested and audited again in each project.

Admin changes land immediately

A parameter change takes effect the moment it’s sent, with no time for anyone to notice.

In practice

Limit who can change your fees.

Only the fee-manager role can request a fee change, and it waits out a delay.

What you set up

  • The open-source components in your contract
  • A fee-manager role
  • A delay on fee changes
  • Tests for allowed, refused and delayed calls
Developer quickstart (opens in a new tab)

Fee manager
requests

Change
approved

New fee
live

Any other
caller

Refused

Illustrative

The approach

Controls you integrate, not a framework you adopt.

Bloxchain Protocol is a set of open-source smart-contract components. Use the ones your application needs.

Protected ownership

Give your own contract separate owner, broadcaster and recovery roles, so one key isn’t the whole story.

Roles per function

Grant and revoke who may call each function, while the contract runs.

Limits on outside calls

Choose which contracts and functions your contract may call, and add a delay or a separate approval.

One flow for every governed function

Request, wait, approve or cancel, and record — the same steps whichever component you use.

Before you ship

What the Protocol enforces — and what your code must.

Integrating controls moves enforcement on-chain. It doesn’t review the rest of your contract for you.

Enforced by the controls you integrate

  • The roles and permissions you configure per function
  • Delays and approvals on the operations you choose to govern
  • Refusing calls from addresses without the required role
  • An on-chain record of governed operations

Your responsibility

  • Deciding which functions to govern, and how
  • Your own contract code — it needs its own security review
  • The independent audit covers the Protocol’s core contracts, not your integration
  • Key management and monitoring

Start with one important function.

Integrate one control, test the allowed, refused and governed cases, and inspect the result on-chain.

Quickstart (opens in a new tab)Talk to us