Document not found (404)
+This URL is invalid, sorry. Please use the navigation bar or search to continue.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/getting_started/create_system.html b/getting_started/create_system.html
new file mode 100644
index 0000000..ef10982
--- /dev/null
+++ b/getting_started/create_system.html
@@ -0,0 +1,220 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Create a Component
+Components are plain data structures (classes or structs) that contain data relevant to a specific aspect of an entity. They don't have any logic or methods. Examples of components could be a "Position" component containing x, y, z coordinates.
+Create a Position component with
+bolt component -n position
+which will add a new component to your workspace:
++ ++#![allow(unused)] +fn main() { +use bolt_lang::*; + +declare_id!("Fn1JzzEdyb55fsyduWS94mYHizGhJZuhvjX6DVvrmGbQ"); + +#[component(Position)] +#[program] +pub mod component_position { + use super::*; +} + +#[account] +#[bolt_account(component_id = "component-position")] +#[derive(Copy)] +pub struct Position { + pub x: i64, + pub y: i64, + pub z: i64, +} +} +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/getting_started/getting_started.html b/getting_started/getting_started.html
new file mode 100644
index 0000000..aad41c6
--- /dev/null
+++ b/getting_started/getting_started.html
@@ -0,0 +1,178 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Create a System
+Systems contain the logic that processes and manipulates entities based on their components. A system will typically operate on all entities that have a specific set of components. For example, a "Movement" system might update the position of a "Position" component
+Create a movement system with with
+bolt system -n system-movement
+which will add a new system to your workspace:
++ ++#![allow(unused)] +fn main() { +use bolt_lang::*; + +declare_id!("FSa6qoJXFBR3a7ThQkTAMrC15p6NkchPEjBdd4n6dXxA"); + +#[system] +#[program] +pub mod system_movement { + use super::*; + + pub fn execute(ctx: Context<Component>, args_p: Vec<u8>) -> Result<Position> { + + let mut position = Position::from_account_info(&ctx.accounts.position)?; + + position.x += 1; + position.y += 1; + + Ok(position) + } +} + +// Define the Account to parse from the component +#[derive(Accounts)] +pub struct Component<'info> { + /// CHECK: check that the component is the expected account + pub position: AccountInfo<'info>, +} + +#[component_deserialize] +pub struct Position { + pub x: i64, + pub y: i64, + pub z: i64, +} +} +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/getting_started/hello_bolt.html b/getting_started/hello_bolt.html
new file mode 100644
index 0000000..dd7edeb
--- /dev/null
+++ b/getting_started/hello_bolt.html
@@ -0,0 +1,198 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Getting Started
+This chapter walks you through the installation process and the folder structure of an anchor workspace.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/getting_started/installation.html b/getting_started/installation.html
new file mode 100644
index 0000000..a6f5e0a
--- /dev/null
+++ b/getting_started/installation.html
@@ -0,0 +1,202 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Hello, Bolt!
+To initialize a new project, simply run:
+bolt init <new-workspace-name>
+This creates a new bolt workspace you can move into. The following are some of the important files in the folder:
+-
+
- The
.anchorfolder: It includes the most recent program logs and a local ledger that is used for testing
+ - The
appfolder: An empty folder that you can use to hold your frontend if you use a monorepo
+ - The
programsfolder: This folder contains your programs. It can contain multiple but initially only contains a program with the same name as<new-workspace-name>. This program already contains alib.rsfile with some sample code.
+ - The
testsfolder: The folder that contains your E2E tests. It will already include a file that tests the sample code in theprograms/<new-workspace-name>.
+ - The
migrationsfolder: In this folder you can save your deploy and migration scripts for your programs.
+ - The
Anchor.tomlfile: This file configures workspace wide settings for your programs. Initially, it configures +-
+
- The addresses of your programs on localnet (
[programs.localnet])
+ - A registry your program can be pushed to (
[registry])
+ - A provider which can be used in your tests (
[provider])
+ - Scripts that Anchor executes for you (
[scripts]). Thetestscript is run when runninganchor test. You can run your own scripts withanchor run <script_name>.
+
+ - The addresses of your programs on localnet (
Anchor
+Bolt is built on top of Anchor and supports all Anchor commands, in addition to some extensions. For the complete list of Anchor commands, refer to the Anchor book.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/getting_started/world_program.html b/getting_started/world_program.html
new file mode 100644
index 0000000..e4c0b0b
--- /dev/null
+++ b/getting_started/world_program.html
@@ -0,0 +1,174 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Installation
+Rust
+Go here to install Rust.
+Solana
+Go here to install Solana and then run solana-keygen new to create a keypair at the default location. Anchor uses this keypair to run your program tests.
Yarn
+Go here to install Yarn.
+Anchor
+Installing Anchor
+cargo install --git https://github.com/coral-xyz/anchor avm --locked --force
+Install the 0.29.0 version of the CLI using avm, and then set it to be the version to use.
avm install 0.29.0
+avm use 0.29.0
+Bolt
+Installing Bolt
+Install Bolt using Cargo.
cargo install --git https://github.com/magicblock-labs/bolt --locked --force
+On Linux systems you may need to install additional dependencies if cargo install fails. E.g. on Ubuntu:
+sudo apt-get update && sudo apt-get upgrade && sudo apt-get install -y pkg-config build-essential libudev-dev
+Verify the installation.
+bolt -h
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/highlight.css b/highlight.css
new file mode 100644
index 0000000..c234322
--- /dev/null
+++ b/highlight.css
@@ -0,0 +1,83 @@
+/*
+ * An increased contrast highlighting scheme loosely based on the
+ * "Base16 Atelier Dune Light" theme by Bram de Haan
+ * (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/dune)
+ * Original Base16 color scheme by Chris Kempson
+ * (https://github.com/chriskempson/base16)
+ */
+
+/* Comment */
+.hljs-comment,
+.hljs-quote {
+ color: #575757;
+}
+
+/* Red */
+.hljs-variable,
+.hljs-template-variable,
+.hljs-attribute,
+.hljs-tag,
+.hljs-name,
+.hljs-regexp,
+.hljs-link,
+.hljs-name,
+.hljs-selector-id,
+.hljs-selector-class {
+ color: #d70025;
+}
+
+/* Orange */
+.hljs-number,
+.hljs-meta,
+.hljs-built_in,
+.hljs-builtin-name,
+.hljs-literal,
+.hljs-type,
+.hljs-params {
+ color: #b21e00;
+}
+
+/* Green */
+.hljs-string,
+.hljs-symbol,
+.hljs-bullet {
+ color: #008200;
+}
+
+/* Blue */
+.hljs-title,
+.hljs-section {
+ color: #0030f2;
+}
+
+/* Purple */
+.hljs-keyword,
+.hljs-selector-tag {
+ color: #9d00ec;
+}
+
+.hljs {
+ display: block;
+ overflow-x: auto;
+ background: #f6f7f6;
+ color: #000;
+ padding: 0.5em;
+}
+
+.hljs-emphasis {
+ font-style: italic;
+}
+
+.hljs-strong {
+ font-weight: bold;
+}
+
+.hljs-addition {
+ color: #22863a;
+ background-color: #f0fff4;
+}
+
+.hljs-deletion {
+ color: #b31d28;
+ background-color: #ffeef0;
+}
diff --git a/highlight.js b/highlight.js
new file mode 100644
index 0000000..180385b
--- /dev/null
+++ b/highlight.js
@@ -0,0 +1,6 @@
+/*
+ Highlight.js 10.1.1 (93fd0d73)
+ License: BSD-3-Clause
+ Copyright (c) 2006-2020, Ivan Sagalaev
+*/
+var hljs=function(){"use strict";function e(n){Object.freeze(n);var t="function"==typeof n;return Object.getOwnPropertyNames(n).forEach((function(r){!Object.hasOwnProperty.call(n,r)||null===n[r]||"object"!=typeof n[r]&&"function"!=typeof n[r]||t&&("caller"===r||"callee"===r||"arguments"===r)||Object.isFrozen(n[r])||e(n[r])})),n}class n{constructor(e){void 0===e.data&&(e.data={}),this.data=e.data}ignoreMatch(){this.ignore=!0}}function t(e){return e.replace(/&/g,"&").replace(//g,">").replace(/"/g,""").replace(/'/g,"'")}function r(e,...n){var t={};for(const n in e)t[n]=e[n];return n.forEach((function(e){for(const n in e)t[n]=e[n]})),t}function a(e){return e.nodeName.toLowerCase()}var i=Object.freeze({__proto__:null,escapeHTML:t,inherit:r,nodeStream:function(e){var n=[];return function e(t,r){for(var i=t.firstChild;i;i=i.nextSibling)3===i.nodeType?r+=i.nodeValue.length:1===i.nodeType&&(n.push({event:"start",offset:r,node:i}),r=e(i,r),a(i).match(/br|hr|img|input/)||n.push({event:"stop",offset:r,node:i}));return r}(e,0),n},mergeStreams:function(e,n,r){var i=0,s="",o=[];function l(){return e.length&&n.length?e[0].offset!==n[0].offset?e[0].offset
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ World Program
+The World Program includes instructions for creating world instances, entities, attaching components, and executing systems.
+Client
+The development of SDKs and client integrations is ongoing. However, the World Program is a standard anchor program with its IDL published on-chain. The Anchor IDL generator can be utilized to automatically generate clients.
+ +":e:f.tabReplace?e.replace(/\t/g,f.tabReplace):e):e}function E(e){let n=null;const t=function(e){var n=e.className+" ";n+=e.parentNode?e.parentNode.className:"";const t=f.languageDetectRe.exec(n);if(t){var r=T(t[1]);return r||(console.warn(g.replace("{}",t[1])),console.warn("Falling back to no-highlight mode for this block.",e)),r?t[1]:"no-highlight"}return n.split(/\s+/).find(e=>p(e)||T(e))}(e);if(p(t))return;S("before:highlightBlock",{block:e,language:t}),f.useBR?(n=document.createElement("div")).innerHTML=e.innerHTML.replace(/\n/g,"").replace(/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/introduction/ecs.html b/introduction/ecs.html
new file mode 100644
index 0000000..07df433
--- /dev/null
+++ b/introduction/ecs.html
@@ -0,0 +1,188 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Introduction
+Welcome to The Bolt Book! ⚡
+++Bolt is an open-source project, currently in its early development phase, and warmly welcomes contributors. For additional resources, join the community on Discord.
+
This chapter covers what bolt is, how its documentation is structured, and what you should know to have a good time with this guide.
+If you find errors or something doesn't work, please report it here.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/introduction/ephemeral-rollups.html b/introduction/ephemeral-rollups.html
new file mode 100644
index 0000000..96273d9
--- /dev/null
+++ b/introduction/ephemeral-rollups.html
@@ -0,0 +1,200 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Entity, Component and Systems (ECS)
+The framework includes a standardized way to model the game logic, using the ECS (Entity, Components and Systems), which is commonly used in the gaming industry and also adopted in most on-chain engines.
+This pattern decouples logic from state, enabling optimizations in terms of performance and scalability. Additionally, its modular nature facilitates code reusability and extensibility, which are two essential properties for fully on-chain games and autonomous worlds.
+The Solana Virtual Machine makes use of a paradigm similar to an ECS. The state (the accounts) and the logic (the programs) are natively separated.
+When we compare it to Solana's architecture, it becomes evident how easily the ECS can be implemented:
+-
+
- Entities: An entity is a general-purpose object typically represented by a unique identifier. +It doesn't directly contain any data or behaviour but serves as an identifier for a collection of components. Entities can be registered in a world instance account on Solana and could themselves be accounts. +
- Components: Raw data structure that represents some aspect or attribute of an entity. For instance, a PositionComponent might just contain x, y, and z coordinates. This is concept is essentially equivalent to accounts on Solana. +
- Systems: Performs the game logic or behaviour by acting upon entities that have specific components. Systems are essentialy programs on Solana, which only specify the logic and the accounts they operate on. +
Solana's Program Derived Addresses (PDAs) facilitate the efficient storage and retrieval of entities, components and system mimicking a hash table-like structure.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/introduction/introduction.html b/introduction/introduction.html
new file mode 100644
index 0000000..1a913d3
--- /dev/null
+++ b/introduction/introduction.html
@@ -0,0 +1,177 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Ephemeral Rollups
+The core intuition is that by harnessing the SVM's account structure and its capacity for parallelization, we can split the app/game state into clusters. Users can lock one or multiple accounts to temporarily transfer the state to an auxiliary layer, which we define as the "ephemeral rollup", a configurable dedicated runtime.
+This process temporarily entrusts the sequencer to modify the accounts in the ephemeral rollup, where the state can be forcefully reverted and unlocked on the L1 if constraints are not satisfied (read the whitepaper for more details). Despite this delegation, operations and transactions can still use the delegate accounts as readable on the base layer. Non-delegated accounts remain unaffected and modifiable.
+The ephemeral rollup operates as a specialized SVM runtime to facilitate transaction processing at an elevated throughput. Additionally, this specialized runtime can be customized to include configurations like gasless transactions, quicker block-time, and the inclusion of a ticking mechanism (i.e., an integrated transaction scheduling system like clockwork) operated without fees). The entire process is transparent to the end user - a specialized RPC provider can route the transactions to the base layer and the ephemeral rollup(s) in parallel during the game session.
+White Paper
+
Bolt white paper describes in details the architecture and the scalability solution. We recommend reading the basic concepts of ephemeral rollups in section 2.2 of the Bolt Whitepaper
+Avoiding Fragmentation and Benefits
+The benefit of ER is that programs and assets reside directly on the base layer. Transactions can be accelerated through ERs, which are fully compatible with the Solana Virtual Machine (SVM) down to the bytecode level. Any improvements or advancements at the base layer are immediately available, without the need to modify or re-deploy programs.
+Ephemeral Rollups has the following benefits:
+-
+
-
+
Developers deploy programs to the base layer (e.g., Solana), rather than on a separate chain as it would normally happen with rollups. Programs live on the base layer and can interact with any existing protocol and assets. ERs don't fragment the existing ecosystem and allow the speed-up of targeted operations without creating an isolated environment.
+
+ -
+
Users, developers and programs using ERs can take advantage of Solana's infrastructure. This includes programming languages, code libraries, testing tools, client software, deployment infrastructure etc.
+
+ -
+
The specialized runtime can accommodate game-specific customizations (e.g., ticking or passive events, typical in games, as opposed to the event-driven runtime of blockchains) without the need to pay gas for fees on those specific accounts.
+
+ -
+
This approach enables a highly scalable system capable of launching rollups on-demand, auto-scaling horizontally to accommodate users performing millions of transactions without the tradeoffs of traditional L2s.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/introduction/mapping-and-state-listening.html b/introduction/mapping-and-state-listening.html
new file mode 100644
index 0000000..facf694
--- /dev/null
+++ b/introduction/mapping-and-state-listening.html
@@ -0,0 +1,181 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Introduction
+Welcome to The Bolt Book! ⚡
+++Bolt is an open-source project, currently in its early development phase, and warmly welcomes contributors. For additional resources, join the community on Discord.
+
This chapter covers what bolt is, how its documentation is structured, and what you should know to have a good time with this guide.
+If you find errors or something doesn't work, please report it here.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/introduction/what_is_bolt.html b/introduction/what_is_bolt.html
new file mode 100644
index 0000000..33cbf60
--- /dev/null
+++ b/introduction/what_is_bolt.html
@@ -0,0 +1,186 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Mapping and State listening
+The standardized ECS pattern allows for easy integration of game components with a rendering engine to display the game interface. Bolt can be viewed as an open and permissionless alternative to a backend intended as a multiplayer game server.
+For visualization and rendering, existing engines such as Unity, Unreal Engine, Phaser, and others can be used.
+The standardized structure of the components allows for automatic mapping of components and entity properties (abstracting serialization and deserialization. State updates can be easily performed and intercepted, providing a mechanism similar to the Observer pattern to listen to state changes and update the rendering.
+If you are building with Unity, the Solana.Unity-SDK gives you all the necessary tools to connect the gaming interface with Bolt.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mark.min.js b/mark.min.js
new file mode 100644
index 0000000..1636231
--- /dev/null
+++ b/mark.min.js
@@ -0,0 +1,7 @@
+/*!***************************************************
+* mark.js v8.11.1
+* https://markjs.io/
+* Copyright (c) 2014–2018, Julian Kühnel
+* Released under the MIT license https://git.io/vwTVl
+*****************************************************/
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):e.Mark=t()}(this,function(){"use strict";var e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},t=function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")},n=function(){function e(e,t){for(var n=0;n
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ What is Bolt
+Bolt is a high-performance, scalable SVM-based framework designed for Fully On Chain (FOC) Games and Autonomous Worlds.
+With Bolt, you can create games that live forever on the blockchain. These games are platform-centric by default, empowering users to extend and modify both game content and logic. Bolt facilitates multiplayer gaming experiences with performances on pair with traditional multiplayer servers.
+Furthermore, the framework incorporates an Entity Component System (ECS) architecture, streamlining the game structuring and assembly process and providing ready-to-use components. Developers can reuse and contribute modules and logic deployed on the blockchain.
+All these features collectively reduce the intricacy of crafting fully on-chain games, enabling developers to focus more on the game's essence.
+Explainer
+Here's a video of Magibclock's co-founders explaining how BOLT works at the 2023 Breakpoint Conference:
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/prerequisites/useful_resources.html b/prerequisites/useful_resources.html
new file mode 100644
index 0000000..34c0b48
--- /dev/null
+++ b/prerequisites/useful_resources.html
@@ -0,0 +1,185 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Prerequisites
+This chapter provides you with the necessary background knowledge to get started with bolt.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/print.html b/print.html
new file mode 100644
index 0000000..19bae1f
--- /dev/null
+++ b/print.html
@@ -0,0 +1,366 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Useful Resources
+Rust
+This guide assumes that you already have some knowledge of basic Rust. We recommend reading chapters 1-9 of the Rust book which cover the basics of using Rust (Most of the time you don't need advanced Rust to write anchor programs).
+Solana
+This guide assumes that you already have some knowledge of basic Rust. We recommend reading the basic concepts from the Anchor book
+Anchor
+Bolt is built on top of Anchor, therefore having a general knowledge of Anchor will give you the necessary tool to build the game logic. We recommend reading chapters 1-4 of the Anchor book
+Bolt White Paper
+Bolt white paper describes in details the architecture and the scalability solution. We recommend reading the basic concepts of ephemeral rollups in section 2.2 of the Bolt Whitepaper
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/searcher.js b/searcher.js
new file mode 100644
index 0000000..d2b0aee
--- /dev/null
+++ b/searcher.js
@@ -0,0 +1,483 @@
+"use strict";
+window.search = window.search || {};
+(function search(search) {
+ // Search functionality
+ //
+ // You can use !hasFocus() to prevent keyhandling in your key
+ // event handlers while the user is typing their search.
+
+ if (!Mark || !elasticlunr) {
+ return;
+ }
+
+ //IE 11 Compatibility from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+ if (!String.prototype.startsWith) {
+ String.prototype.startsWith = function(search, pos) {
+ return this.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+ };
+ }
+
+ var search_wrap = document.getElementById('search-wrapper'),
+ searchbar = document.getElementById('searchbar'),
+ searchbar_outer = document.getElementById('searchbar-outer'),
+ searchresults = document.getElementById('searchresults'),
+ searchresults_outer = document.getElementById('searchresults-outer'),
+ searchresults_header = document.getElementById('searchresults-header'),
+ searchicon = document.getElementById('search-toggle'),
+ content = document.getElementById('content'),
+
+ searchindex = null,
+ doc_urls = [],
+ results_options = {
+ teaser_word_count: 30,
+ limit_results: 30,
+ },
+ search_options = {
+ bool: "AND",
+ expand: true,
+ fields: {
+ title: {boost: 1},
+ body: {boost: 1},
+ breadcrumbs: {boost: 0}
+ }
+ },
+ mark_exclude = [],
+ marker = new Mark(content),
+ current_searchterm = "",
+ URL_SEARCH_PARAM = 'search',
+ URL_MARK_PARAM = 'highlight',
+ teaser_count = 0,
+
+ SEARCH_HOTKEY_KEYCODE = 83,
+ ESCAPE_KEYCODE = 27,
+ DOWN_KEYCODE = 40,
+ UP_KEYCODE = 38,
+ SELECT_KEYCODE = 13;
+
+ function hasFocus() {
+ return searchbar === document.activeElement;
+ }
+
+ function removeChildren(elem) {
+ while (elem.firstChild) {
+ elem.removeChild(elem.firstChild);
+ }
+ }
+
+ // Helper to parse a url into its building blocks.
+ function parseURL(url) {
+ var a = document.createElement('a');
+ a.href = url;
+ return {
+ source: url,
+ protocol: a.protocol.replace(':',''),
+ host: a.hostname,
+ port: a.port,
+ params: (function(){
+ var ret = {};
+ var seg = a.search.replace(/^\?/,'').split('&');
+ var len = seg.length, i = 0, s;
+ for (;i
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Introduction
+Welcome to The Bolt Book! ⚡
+++Bolt is an open-source project, currently in its early development phase, and warmly welcomes contributors. For additional resources, join the community on Discord.
+
This chapter covers what bolt is, how its documentation is structured, and what you should know to have a good time with this guide.
+If you find errors or something doesn't work, please report it here.
+What is Bolt
+Bolt is a high-performance, scalable SVM-based framework designed for Fully On Chain (FOC) Games and Autonomous Worlds.
+With Bolt, you can create games that live forever on the blockchain. These games are platform-centric by default, empowering users to extend and modify both game content and logic. Bolt facilitates multiplayer gaming experiences with performances on pair with traditional multiplayer servers.
+Furthermore, the framework incorporates an Entity Component System (ECS) architecture, streamlining the game structuring and assembly process and providing ready-to-use components. Developers can reuse and contribute modules and logic deployed on the blockchain.
+All these features collectively reduce the intricacy of crafting fully on-chain games, enabling developers to focus more on the game's essence.
+Explainer
+Here's a video of Magibclock's co-founders explaining how BOLT works at the 2023 Breakpoint Conference:
+Entity, Component and Systems (ECS)
+The framework includes a standardized way to model the game logic, using the ECS (Entity, Components and Systems), which is commonly used in the gaming industry and also adopted in most on-chain engines.
+This pattern decouples logic from state, enabling optimizations in terms of performance and scalability. Additionally, its modular nature facilitates code reusability and extensibility, which are two essential properties for fully on-chain games and autonomous worlds.
+The Solana Virtual Machine makes use of a paradigm similar to an ECS. The state (the accounts) and the logic (the programs) are natively separated.
+When we compare it to Solana's architecture, it becomes evident how easily the ECS can be implemented:
+-
+
- Entities: An entity is a general-purpose object typically represented by a unique identifier. +It doesn't directly contain any data or behaviour but serves as an identifier for a collection of components. Entities can be registered in a world instance account on Solana and could themselves be accounts. +
- Components: Raw data structure that represents some aspect or attribute of an entity. For instance, a PositionComponent might just contain x, y, and z coordinates. This is concept is essentially equivalent to accounts on Solana. +
- Systems: Performs the game logic or behaviour by acting upon entities that have specific components. Systems are essentialy programs on Solana, which only specify the logic and the accounts they operate on. +
Solana's Program Derived Addresses (PDAs) facilitate the efficient storage and retrieval of entities, components and system mimicking a hash table-like structure.
+Ephemeral Rollups
+The core intuition is that by harnessing the SVM's account structure and its capacity for parallelization, we can split the app/game state into clusters. Users can lock one or multiple accounts to temporarily transfer the state to an auxiliary layer, which we define as the "ephemeral rollup", a configurable dedicated runtime.
+This process temporarily entrusts the sequencer to modify the accounts in the ephemeral rollup, where the state can be forcefully reverted and unlocked on the L1 if constraints are not satisfied (read the whitepaper for more details). Despite this delegation, operations and transactions can still use the delegate accounts as readable on the base layer. Non-delegated accounts remain unaffected and modifiable.
+The ephemeral rollup operates as a specialized SVM runtime to facilitate transaction processing at an elevated throughput. Additionally, this specialized runtime can be customized to include configurations like gasless transactions, quicker block-time, and the inclusion of a ticking mechanism (i.e., an integrated transaction scheduling system like clockwork) operated without fees). The entire process is transparent to the end user - a specialized RPC provider can route the transactions to the base layer and the ephemeral rollup(s) in parallel during the game session.
+White Paper
+
Bolt white paper describes in details the architecture and the scalability solution. We recommend reading the basic concepts of ephemeral rollups in section 2.2 of the Bolt Whitepaper
+Avoiding Fragmentation and Benefits
+The benefit of ER is that programs and assets reside directly on the base layer. Transactions can be accelerated through ERs, which are fully compatible with the Solana Virtual Machine (SVM) down to the bytecode level. Any improvements or advancements at the base layer are immediately available, without the need to modify or re-deploy programs.
+Ephemeral Rollups has the following benefits:
+-
+
-
+
Developers deploy programs to the base layer (e.g., Solana), rather than on a separate chain as it would normally happen with rollups. Programs live on the base layer and can interact with any existing protocol and assets. ERs don't fragment the existing ecosystem and allow the speed-up of targeted operations without creating an isolated environment.
+
+ -
+
Users, developers and programs using ERs can take advantage of Solana's infrastructure. This includes programming languages, code libraries, testing tools, client software, deployment infrastructure etc.
+
+ -
+
The specialized runtime can accommodate game-specific customizations (e.g., ticking or passive events, typical in games, as opposed to the event-driven runtime of blockchains) without the need to pay gas for fees on those specific accounts.
+
+ -
+
This approach enables a highly scalable system capable of launching rollups on-demand, auto-scaling horizontally to accommodate users performing millions of transactions without the tradeoffs of traditional L2s.
+
+
Mapping and State listening
+The standardized ECS pattern allows for easy integration of game components with a rendering engine to display the game interface. Bolt can be viewed as an open and permissionless alternative to a backend intended as a multiplayer game server.
+For visualization and rendering, existing engines such as Unity, Unreal Engine, Phaser, and others can be used.
+The standardized structure of the components allows for automatic mapping of components and entity properties (abstracting serialization and deserialization. State updates can be easily performed and intercepted, providing a mechanism similar to the Observer pattern to listen to state changes and update the rendering.
+If you are building with Unity, the Solana.Unity-SDK gives you all the necessary tools to connect the gaming interface with Bolt.
+Prerequisites
+This chapter provides you with the necessary background knowledge to get started with bolt.
+Useful Resources
+Rust
+This guide assumes that you already have some knowledge of basic Rust. We recommend reading chapters 1-9 of the Rust book which cover the basics of using Rust (Most of the time you don't need advanced Rust to write anchor programs).
+Solana
+This guide assumes that you already have some knowledge of basic Rust. We recommend reading the basic concepts from the Anchor book
+Anchor
+Bolt is built on top of Anchor, therefore having a general knowledge of Anchor will give you the necessary tool to build the game logic. We recommend reading chapters 1-4 of the Anchor book
+Bolt White Paper
+Bolt white paper describes in details the architecture and the scalability solution. We recommend reading the basic concepts of ephemeral rollups in section 2.2 of the Bolt Whitepaper
+Getting Started
+This chapter walks you through the installation process and the folder structure of an anchor workspace.
+Installation
+Rust
+Go here to install Rust.
+Solana
+Go here to install Solana and then run solana-keygen new to create a keypair at the default location. Anchor uses this keypair to run your program tests.
Yarn
+Go here to install Yarn.
+Anchor
+Installing Anchor
+cargo install --git https://github.com/coral-xyz/anchor avm --locked --force
+Install the 0.29.0 version of the CLI using avm, and then set it to be the version to use.
avm install 0.29.0
+avm use 0.29.0
+Bolt
+Installing Bolt
+Install Bolt using Cargo.
cargo install --git https://github.com/magicblock-labs/bolt --locked --force
+On Linux systems you may need to install additional dependencies if cargo install fails. E.g. on Ubuntu:
+sudo apt-get update && sudo apt-get upgrade && sudo apt-get install -y pkg-config build-essential libudev-dev
+Verify the installation.
+bolt -h
+Hello, Bolt!
+To initialize a new project, simply run:
+bolt init <new-workspace-name>
+This creates a new bolt workspace you can move into. The following are some of the important files in the folder:
+-
+
- The
.anchorfolder: It includes the most recent program logs and a local ledger that is used for testing
+ - The
appfolder: An empty folder that you can use to hold your frontend if you use a monorepo
+ - The
programsfolder: This folder contains your programs. It can contain multiple but initially only contains a program with the same name as<new-workspace-name>. This program already contains alib.rsfile with some sample code.
+ - The
testsfolder: The folder that contains your E2E tests. It will already include a file that tests the sample code in theprograms/<new-workspace-name>.
+ - The
migrationsfolder: In this folder you can save your deploy and migration scripts for your programs.
+ - The
Anchor.tomlfile: This file configures workspace wide settings for your programs. Initially, it configures +-
+
- The addresses of your programs on localnet (
[programs.localnet])
+ - A registry your program can be pushed to (
[registry])
+ - A provider which can be used in your tests (
[provider])
+ - Scripts that Anchor executes for you (
[scripts]). Thetestscript is run when runninganchor test. You can run your own scripts withanchor run <script_name>.
+
+ - The addresses of your programs on localnet (
Anchor
+Bolt is built on top of Anchor and supports all Anchor commands, in addition to some extensions. For the complete list of Anchor commands, refer to the Anchor book.
+Create a Component
+Components are plain data structures (classes or structs) that contain data relevant to a specific aspect of an entity. They don't have any logic or methods. Examples of components could be a "Position" component containing x, y, z coordinates.
+Create a Position component with
+bolt component -n position
+which will add a new component to your workspace:
+++#![allow(unused)] +fn main() { +use bolt_lang::*; + +declare_id!("Fn1JzzEdyb55fsyduWS94mYHizGhJZuhvjX6DVvrmGbQ"); + +#[component(Position)] +#[program] +pub mod component_position { + use super::*; +} + +#[account] +#[bolt_account(component_id = "component-position")] +#[derive(Copy)] +pub struct Position { + pub x: i64, + pub y: i64, + pub z: i64, +} +} +
Create a System
+Systems contain the logic that processes and manipulates entities based on their components. A system will typically operate on all entities that have a specific set of components. For example, a "Movement" system might update the position of a "Position" component
+Create a movement system with with
+bolt system -n system-movement
+which will add a new system to your workspace:
+++#![allow(unused)] +fn main() { +use bolt_lang::*; + +declare_id!("FSa6qoJXFBR3a7ThQkTAMrC15p6NkchPEjBdd4n6dXxA"); + +#[system] +#[program] +pub mod system_movement { + use super::*; + + pub fn execute(ctx: Context<Component>, args_p: Vec<u8>) -> Result<Position> { + + let mut position = Position::from_account_info(&ctx.accounts.position)?; + + position.x += 1; + position.y += 1; + + Ok(position) + } +} + +// Define the Account to parse from the component +#[derive(Accounts)] +pub struct Component<'info> { + /// CHECK: check that the component is the expected account + pub position: AccountInfo<'info>, +} + +#[component_deserialize] +pub struct Position { + pub x: i64, + pub y: i64, + pub z: i64, +} +} +
World Program
+The World Program includes instructions for creating world instances, entities, attaching components, and executing systems.
+Client
+The development of SDKs and client integrations is ongoing. However, the World Program is a standard anchor program with its IDL published on-chain. The Anchor IDL generator can be utilized to automatically generate clients.
+ +