- In general computing, Scancodes are the unique codes that are sent by a keyboard to a computer's operating system (or, in the Qubic case, the UEFI system) to denote each individual key press and release. When a key is pressed, the keyboard sends a "Make" scancode to the system, and when it is released, it sends a "Break" scancode. -
-- Scancodes are used to map the physical keys on a keyboard to characters or functions on the computer. This allows for flexibility in keyboard layout and design, as the scancodes can be mapped differently for different keyboard layouts (like QWERTY vs AZERTY) or for different languages. -
-Relevant Scancodes
-| 0x0B | F1 | -
| 0x0C | F2 | -
| 0x0D | F3 | -
| 0x0E | F4 | -
| 0x10 | F6 | -
| 0x17 | ESC | -
Note:EFI scancodes are different from Linux/UNIX ones.
-Reference: https://uefi.org/specs/UEFI/2.10/Apx_B_Console.html
-
-230726121457 A- 000:000(000).0.0 Qubic 1.156.0 is launched.{'\n'}
-230726121457 A- 000:000(000).0.0 Theoretical TSC frequency = n/a.{'\n'}
-230726121457 A- 000:000(000).0.0 Practical TSC frequency = 4'192'091'411 Hz.{'\n'}
-230726121457 A- 000:000(000).0.0 Volume #0 (): 13'946'601'472 / 21'464'301'568 free bytes | Read-Write.{'\n'}
-230726121457 A- 000:000(000).7100000.67 1'073'741'824 bytes of the spectrum data are hashed (3'765'499 microseconds).{'\n'}
-230726121457 A- 000:000(000).7100000.67 56'860'000'000'000 qus in 2'722 entities (digest = rcughairuagqwfyzgqfubfqrzvceutzjufgcdveznakqwvumjczgehdboupo).{'\n'}
-230726121457 A- 000:000(000).7100000.67 Universe digest = tqoshbcixaychhxgzykrrdnhdoragtqjjrrgwvwadfghzsgyfkdtdnzfwjnk.{'\n'}
-230726121457 A- 000:000(000).7100000.67 Computer digest = enqmdlcdojeyxbonwdxlkzzchsubzivlqrkbnoxbwbkkcrbnbvrjbopfkrka.{'\n'}
-230726121457 A- 000:000(000).7100000.67 14/14 processors are being used.{'\n'}
-230726121457 A- 000:000(000).7100000.67 Local address = 123.100.321.100:21841.{'\n'}
-230726121457 A- 000:000(000).7100000.67 Routes:{'\n'}
-230726121457 A- 000:000(000).7100000.67 Address = 123.100.321.50 | mask = 255.255.255.192 | gateway = 0.0.0.0.{'\n'}
-230726121457 A- 000:000(000).7100000.67 Address = 0.0.0.0 | mask = 0.0.0.0 | gateway = 123.100.321.55.{'\n'}
-230726121511 A- 000:000(000).7100000.67 [+0 -0 *0 /0] 0|0 0/22 Dynamic (+0 -0 ...0).{'\n'}
-230726121511 A- 000:000(000).7100000.67 11 | Tick = 0.0 s | Indices = ?.{'\n'}
-230726121511 A- 000:000(000).7100000.67 0/0 next tick transactions are known. 0 pending transactions.{'\n'}
-230726121511 A- 000:000(000).7100000.67 0 (0) :: 0 (0) | Average processing time = ? microseconds.{'\n'}
-230726121511 A- 000:000(000).7100000.67 Ticker loop duration = 0 microseconds. Latest created tick = 0.{'\n'}
-230726121512 A- 000:000(000).7100000.67 [+31 -0 *6 /44] 70|14 11/28 Dynamic (+2'108 -2'336 ...0).{'\n'}
-230726121512 A- 000:000(000).7100000.67 11 | Tick = 0.0 s | Indices = ?.{'\n'}
-
-
-- Current protocol version
-
-## Votes
-
--230726122051 B- 000:000(000).7100027.67 0/0 next tick transactions are known. 59 pending transactions.{'\n'} -- -- Aligned Votes (votes on the left): These computors have the same data for the tick and are potentially aligned with tick leaders view. To proceed to next tick quorum (451+) must be aligned. -- Misaligned votes (votes on the right): computors can have different view, meaning they are misaligned if they do not agree with majority. -- Computors ahead of your computor - - -## Connections -
-230726122052 B- 000:000(000).7100027.67 [+26 -0 *129 /38] 52|12 30/39 Dynamic (+44'252 -145'608 ...129'180).{'\n'} -230726122052 B- 000:000(000).7100027.67 11 | Tick = 7.4 s | Indices = AX[in 24 ticks]+BS[45]+DE[83].{'\n'} -- -- Not connected slots -- Connected slots - -Default config is 64 connections overall (60 incoming, 4 outgoing). - -## Tick durations -
-230726122051 B- 000:000(000).7100027.67 0 (0) :: 0 (0) | Average processing time = 87 microseconds.{'\n'}
-230726122051 B- 000:000(000).7100027.67 Ticker loop duration = 4 microseconds. Latest created tick = 7'100'026.{'\n'}
-
-
-## To be continued...
-
-
-230726122059 B- 000:000(000).7100028.67 0 (0) :: 0 (0) | Average processing time = 85 microseconds.{'\n'}
-230726122059 B- 000:000(000).7100028.67 Ticker loop duration = 4 microseconds. Latest created tick = 7'100'027.{'\n'}
-230726122100 D4'202'496+ 359:000(000).7100028.67 [+371 -0 *1'071 /3'443] 51|33 30/39 Dynamic (+491'316 -644'428 ...398'808).{'\n'}
-230726122100 D4'202'496+ 359:000(000).7100028.67 11 | Tick = 7.4 s | Indices = AX[in 23 ticks]+BS[44]+DE[82].{'\n'}
-230726122100 D4'202'496+ 359:000(000).7100028.67 0/0 next tick transactions are known. 61 pending transactions.{'\n'}
-230726122100 D4'202'496+ 359:000(000).7100028.67 0 (0) :: 0 (0) | Average processing time = 84 microseconds.{'\n'}
-230726122100 D4'202'496+ 359:000(000).7100028.67 Ticker loop duration = 9 microseconds. Latest created tick = 7'100'028.{'\n'}
-230726122101 B- 000:000(000).7100029.67 [+160 -0 *1'034 /903] 50|34 30/39 Dynamic (+392'912 -480'164 ...216'164).{'\n'}
-
-
-
-230726122217 C- 000:000(000).7100042.67 [+485 -0 *2'545 /4'519] 46|38 30/38 Dynamic (+1'033'796 -1'309'196 ...246'604).{'\n'}
-230726122217 C- 000:000(000).7100042.67 11 | Tick = 5.8 s | Indices = AX[in 9 ticks].{'\n'}
-230726122217 C- 000:000(000).7100042.67 ?/? next tick transactions are known. (23.07.26 12:22:13.) 38 pending transactions.{'\n'}
-
\ No newline at end of file
diff --git a/docs/computors/prerequisites.md b/docs/computors/prerequisites.md
deleted file mode 100644
index 536fa01..0000000
--- a/docs/computors/prerequisites.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# Prerequisites
-
-Becoming a Computor on the Qubic platform involves a range of prerequisites related to your hardware, software, and networking capabilities. Meeting these requirements ensures that you can successfully perform the necessary tasks within the network, including executing smart contracts and maintaining the Spectrum.
-
-# Hardware Requirements:
-
-* Processor (CPU): The processor's speed directly impacts the computational power of a Computor. More powerful processors can handle complex calculations more efficiently. Specific CPU requirements are:
-
- * CPU Frequency: **3+ GHz**
-
- Recommended CPU (as of Q4 2024): **AMD Epyc 24core+**
-
-* Memory (RAM): Adequate memory is crucial for smoothly running operations. More RAM allows a Computor to process larger amounts of data simultaneously. Specific RAM requirements are:
-
- * RAM Size: **1 TB** (will rise to 2TB in Q1 2025)
-
-* Storage: Storage requirements relate to the disk space needed to store the network's Spectrum, smart contracts, and other necessary data. Basically, you need a bit more space on the disk than you need RAM in order to write all data from the RAM back to the disk at the end of each epoch. Recommended storage requirements are:
-
- * Storage Size: **256 GB NVMe**
-
-# Software Requirements:
-
-* Operating System: Qubic runs on bare metal and in UEFI mode, which significantly improves both efficiency and security. The system does not run on a conventional OS, which reduces overhead and makes the most of your hardware.
-
-* Programming Skills: Computors need to be capable of handling smart contracts written in C++. Prior knowledge and experience in C++ are beneficial.
-
-# Network Requirements:
-
-Internet Connection: An efficient and reliable internet connection is essential for participating in the Qubic network. This allows for swift interaction with other Computors and timely execution of tasks. Specific network speed requirements are:
-
-* Network Speed: **1 Gbit/s ** (download/upload)
-
-* Network Compatibility: Your system must be compatible with the Qubic network and meet certain technical standards. This ensures that your system can communicate effectively with other nodes within the network. Most important, you need a port forwarding in your router to **port 21841** of your Computor node.
-
-Please note that these requirements may vary based on the needs and updates of the Qubic platform. Meeting these prerequisites will help you perform effectively as a Computor within the network.
diff --git a/docs/computors/upgrading.md b/docs/computors/upgrading.md
deleted file mode 100644
index 3fd84ff..0000000
--- a/docs/computors/upgrading.md
+++ /dev/null
@@ -1 +0,0 @@
-# Upgrading
\ No newline at end of file
diff --git a/docs/computors/vm.md b/docs/computors/vm.md
deleted file mode 100644
index 55c8081..0000000
--- a/docs/computors/vm.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Virtual Machine
-date: 2023-08-13T19:58:21.745Z
----
-
-# Virtual Machine (VM)
-
-:::info
-
-This part of the documentation is just being drafted and should be ready in the next couple of weeks. In the meanwhile check [https://github.com/digitw1n/run-qubic-on-qemu](https://github.com/digitw1n/run-qubic-on-qemu) if you'd like to try your Virtual Machine (VM) setup or ask in the Discord for help.
-
-:::
\ No newline at end of file
diff --git a/docs/developers/client-qubicj-shell.md b/docs/developers/client-qubicj-shell.md
deleted file mode 100644
index 5a15d12..0000000
--- a/docs/developers/client-qubicj-shell.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: Qubic Java Shell
----
-
-# Qubic Java Shell (qubicj-shell)
-
-The Qubic Java Shell (`qubicj-shell` - a terminal and command line client and wallet) is an intermediate tool that allows
-
-* to communicate with the Qubic Core nodes and
-* provides wallet functionality.
-
-It uses and is part of the Qubic Java Library. You can get the code and the documentation here:
-[Qubic Java repository](https://gitlab.com/qubic-contributions/qubicj) /
-[QubicJ Shell submodule](https://gitlab.com/qubic-contributions/qubicj/-/blob/main/qubicj-shell).
-
-The latest `qubicj-shell` release is always available here:
-[Release Page](https://gitlab.com/qubic-contributions/qubicj/-/releases/permalink/latest).
-
-Qubicj is a community project.
\ No newline at end of file
diff --git a/docs/developers/contribute.md b/docs/developers/contribute.md
deleted file mode 100644
index 441f649..0000000
--- a/docs/developers/contribute.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# Contribute to Qubic
-
-Qubic is more than just a decentralized network; it is a community-driven ecosystem, which thrives on the contributions of its diverse and dedicated members. As we embark on this journey of building an equitable, decentralized future, we're calling upon the talents and creativity of developers and marketers like you.
-
-## Why do we need you?
-
-Innovative and efficient development is at the heart of Qubic's technology. It's the developers who breathe life into our ecosystem by building robust applications, crafting smart contracts and enhancing the core functionality of the network.
-
-Meanwhile, skilled marketers help us convey the potential and value of Qubic to a wider audience, ensuring that our community continues to grow and that the network's benefits reach as many people as possible.
-
-Take a look at our current community bounties and start contributing your unique skills to this innovative ecosystem. Remember, when you deliver quality work, the quorum can vote on the final proposal and release the QUs you've earned. This ensures that your hard work and dedication are recognized and rewarded.
-
-Whether you're coding the next big smart contract or helping to spread the word about Qubic, your contributions shape our collective future. Let's make a difference together in the Qubic ecosystem.
-
-## Contributing to Documentation
-
-If you're a developer interested in contributing to the Qubic documentation, you can find the repository and instructions on how to do it here: https://github.com/qubic/docs
-
-## How we fund these projects
-
-The Computor Controlled Fund (CCF) is a communal resource designed to support and facilitate the growth of the Qubic ecosystem. The fund allocates resources to approved projects that aim to expand the capabilities, reach, or efficiency of the Qubic network. Any community member can propose a project for funding and the projects are chosen based on the votes of the community members (see how [Proposal](/learn/proposals) work). The idea behind the CCF is to enable quick definition of project proposals and release of budgets by the community.
-
-:::info
-Remember, the CCF belongs to all of us. Let's work together to continue developing and growing the Qubic ecosystem!
-:::
\ No newline at end of file
diff --git a/docs/developers/dev-kit.md b/docs/developers/dev-kit.md
deleted file mode 100644
index f5e5164..0000000
--- a/docs/developers/dev-kit.md
+++ /dev/null
@@ -1,70 +0,0 @@
----
-title: Qubic Dev Kit
----
-
-# Qubic Dev Kit
-
-The [Qubic Dev Kit](https://github.com/qubic/qubic-dev-kit) is your go-to tool for setting up a Qubic testnet node and running the HM25 Smart Contract demo for Hackathon Madrid 2025. It streamlines the process for developers looking to create and test their own smart contracts.
-
-## Important Notes
-
-- **Dev Kit Requirements**: Essential for developing and testing smart contracts, simulating the entire Qubic blockchain in a single environment. If you only need to interact with existing contracts, consider using the RPC API and wallet solutions instead.
-
-- **Support and Resources**: For any questions or if you need a server setup, please reach out in the #dev channel on our Discord. We may be able to provide server resources and assistance.
-
-## Overview
-
-The Dev Kit manages:
-- Complete Qubic development environment setup
-- EFI file building
-- Testnet node deployment with your smart contract
-- RPC access for testing
-
-## Development Environment Setup
-
-To set up the environment for developing QUBIC smart contracts, you need two main components: `Visual Studio` and the [`Qubic Core`](https://github.com/qubic/core) repository.
-
-:::info
-We recommend using [Qubic Core Lite](smart-contracts/resources/qubic-lite-core.md) repo instead of the official Qubic Core so you can build and run the local testnet with your smart contract **directly in OS** without using a VM.
-:::
-
-### 1. Install Visual Studio
-
-1. Go to [https://visualstudio.microsoft.com/](https://visualstudio.microsoft.com/) and download Visual Studio
-2. Open the Visual Studio Installer and select the `Desktop development with C++` workload
-3. Complete the installation process
-
-### 2. Clone and Setup the Repository
-
-1. Choose `Clone a repository` in Visual Studio
-2. Paste the URL: `https://github.com/qubic/core.git`
-3. Once cloned, open `Qubic.sln` from the solution explorer
-4. Test your setup by right-clicking the `test` project and selecting `Build`
-
-If you see successful build logs, congratulations! Your development environment is ready.
-
-## Getting Started with Dev Kit
-
-For complete documentation and setup instructions, check out the Dev Kit on GitHub: [Qubic Dev Kit](https://github.com/qubic/qubic-dev-kit)
-
-The Dev Kit provides a streamlined workflow for:
-- Setting up a complete development environment
-- Building and testing smart contracts locally
-- Deploying to testnet for integration testing
-
-## Key Features
-
-- **Optimized for Demo Branch**: The Dev Kit works with the `madrid-2025` branch of the Qubic core repository
-- **Built-in Smart Contract Template**: Includes the HM25 template smart contract with Echo and Burn functions
-- **One-Command Deployment**: Deploy a complete node with your smart contract using a single command
-- **Local Testing Environment**: Run a complete Qubic testnet locally for development and testing
-
-## Next Steps
-
-After setting up your environment:
-
-1. **Learn Smart Contract Structure**: Check out our [Smart Contract Overview](smart-contracts/overview.md)
-2. **Follow the Getting Started Guide**: Complete the [Getting Started Tutorial](smart-contracts/getting-started/setup-environment.md)
-3. **Understand QPI**: Read about the [Qubic Programming Interface](qpi.md)
-4. **Explore Examples**: Look at [Smart Contract Examples](smart-contracts/sc-by-examples/assets-and-shares.md)
-
diff --git a/docs/developers/empty.md b/docs/developers/empty.md
deleted file mode 100644
index e69de29..0000000
diff --git a/docs/developers/frontend-integration.md b/docs/developers/frontend-integration.md
deleted file mode 100644
index fa74ca9..0000000
--- a/docs/developers/frontend-integration.md
+++ /dev/null
@@ -1,94 +0,0 @@
----
-title: Frontend Integration
----
-
-# Building Frontend Applications for Qubic
-
-This guide provides an overview of how to build frontend applications that interact with Qubic smart contracts, with links to complete reference implementations.
-
-## Key Components of a Qubic dApp
-
-A typical Qubic dApp consists of:
-1. A frontend user interface
-2. Wallet integration for transaction signing
-3. RPC communication with Qubic nodes
-4. Smart contract interaction logic
-
-## Complete Frontend Example
-
-The most comprehensive example of a Qubic frontend application can be found in the [HM25 Frontend Example repository](https://github.com/icyblob/hm25-frontend). This repository demonstrates:
-
-- Complete wallet integrations (MetaMask Snap, WalletConnect, seed phrase, Vault file)
-- Smart contract interaction patterns
-- Transaction signing and broadcasting
-- Real-time data fetching from Qubic nodes
-
-We highly recommend exploring this codebase as a starting point for your application.
-
-## Wallet Integration
-
-Qubic supports multiple wallet integration options, all demonstrated in the [HM25 Frontend Example](https://github.com/icyblob/hm25-frontend):
-
-- **MetaMask Snap integration** - For users who already use MetaMask
-- **WalletConnect support** - For interoperability with compatible wallets
-- **Seed phrase login** - For direct access with a seed phrase (not recommended)
-- **Vault file authentication** - For secure stored identities (not recommended)
-
-## Connecting to Nodes
-
-Your application will need to connect to a Qubic node via the RPC API:
-
-- **Public mainnet node**: `https://rpc.qubic.org`
-- **Custom node**: Your own deployed node (see [Qubic Node documentation](qubic-node.md))
-
-The [Qubic TypeScript Library](https://github.com/qubic/ts-library) provides tools for connecting to nodes:
-
-```javascript
-import { QubicConnector } from 'qubic-ts-library/dist/qubicConnector'
-const connector = new QubicConnector("https://rpc.qubic.org");
-```
-
-## Smart Contract Interaction Patterns
-
-There are two main ways to interact with smart contracts:
-
-1. **Reading data** (using functions)
- - Use the `/v1/querySmartContract` RPC endpoint
- - See the [HM25 Frontend HM25Api.jsx](https://github.com/icyblob/hm25-frontend/blob/main/src/components/api/HM25Api.jsx) for implementation
-
-2. **Writing data** (using procedures)
- - Create, sign, and broadcast transactions
- - Target the contract with the appropriate function index and parameters
- - See the Echo and Burn function implementations in the HM25 Frontend example
-
-For implementation details, explore:
-- [`fetchHM25Stats`](https://github.com/icyblob/hm25-frontend/blob/main/src/components/api/HM25Api.jsx#L9) - Example of reading from a contract
-- [`buildEchoTx`](https://github.com/icyblob/hm25-frontend/blob/main/src/components/api/HM25Api.jsx#L39) - Example of creating a transaction for a contract procedure
-
-## Required Libraries
-
-1. **Qubic TypeScript Library**
- ```bash
- yarn add @qubic-lib/qubic-ts-library
- ```
-
-2. **Optional: Qubic Vault Library** (for vault file support)
- ```bash
- yarn add @qubic-lib/qubic-ts-vault-library
- ```
-
-## Development Workflow
-
-1. **Setup Project**: Create a React/Vue/Angular project
-2. **Install Libraries**: Add the Qubic TypeScript Library
-3. **Configure Node Connection**: Set up connector to testnet or custom node
-4. **Implement Wallet Integration**: Use the patterns from HM25 Frontend
-5. **Build Smart Contract Interface**: Create functions that read/write to your contract
-6. **Develop UI Components**: Create forms, displays and interaction elements
-
-## Next Steps
-
-- Explore the [Qubic TypeScript Library documentation](library-typescript.md)
-- Read the [RPC API documentation](../api/rpc) for all available endpoints
-- Clone and study the [HM25 Frontend Example](https://github.com/icyblob/hm25-frontend)
-- Check the [Smart Contract documentation](../learn/smart-contracts.md) to understand the backend
\ No newline at end of file
diff --git a/docs/developers/grants.md b/docs/developers/grants.md
deleted file mode 100644
index 364e813..0000000
--- a/docs/developers/grants.md
+++ /dev/null
@@ -1,9 +0,0 @@
----
-title: Grants Program
----
-
-# Grants Program
-
-The Grants Program aims to foster the development of high-quality smart contracts and solutions that enhance the Qubic ecosystem.
-
-For full documentation, please visit the [Qubic Grants Program GitHub repository](https://github.com/qubic/grants).
diff --git a/docs/developers/integration.md b/docs/developers/integration.md
deleted file mode 100644
index b5df777..0000000
--- a/docs/developers/integration.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-title: Qubic Integration
----
-
-# Integration
-
-You can find the documentation and code here: [Qubic Integration GitHub repository](https://github.com/qubic/integration?tab=readme-ov-file)
diff --git a/docs/developers/interact-with-sc.md b/docs/developers/interact-with-sc.md
deleted file mode 100644
index 6bcb902..0000000
--- a/docs/developers/interact-with-sc.md
+++ /dev/null
@@ -1,75 +0,0 @@
-First, locate the function you want to query in the smart contract code. In this example, we'll use the Fees function from the QX contract.
-
-#Step 1: Identify the Smart Contract Function
-
-
-```
-struct QX : public ContractBase
-{
-public:
- struct Fees_input
- {
- };
- struct Fees_output
- {
- uint32 assetIssuanceFee; // Amount of qus
- uint32 transferFee; // Amount of qus
- uint32 tradeFee; // Number of billionths
- };
- // ...
-}
-
-struct QX : public ContractBase
-{
-public:
- struct Fees_input
- {
- };
- struct Fees_output
- {
- uint32 assetIssuanceFee; // Amount of qus
- uint32 transferFee; // Amount of qus
- uint32 tradeFee; // Number of billionths
- };
- // ...
-}
-```
-
-Step 2: Find the Function Registration
-Look for the REGISTER_USER_FUNCTION keyword to find the function number:
-
-```
-REGISTER_USER_FUNCTION(Fees, 1)
-```
-
-This tells us that the Fees function is registered with the number 1.
-
-## Step 3: Determine the Contract Index
-Find the contract index in the contract definition file:
-
-```
-#define CONTRACT_INDEX_QX 1
-```
-
-This tells us that the QX contract is registered with the index 1.
-
-## Step 4: Construct the API Request
-
-Now we can create a curl command to query the smart contract:
-```
-
-curl -X 'POST' \
- 'https://rpc.qubic.org/v1/querySmartContract' \
- -H 'accept: application/json' \
- -H 'Content-Type: application/json' \
- -d '{
- "contractIndex": 1,
- "inputType": 1,
- "inputSize": 0,
- "requestData": ""
-}'
-
-this should return a response like:
-{"responseData":"AMqaO0BCDwBAS0wA"}
-```
-
diff --git a/docs/developers/intro.md b/docs/developers/intro.md
deleted file mode 100644
index e7c7dd5..0000000
--- a/docs/developers/intro.md
+++ /dev/null
@@ -1,76 +0,0 @@
----
-title: Become a developer
----
-
-# Become a Developer
-
-Welcome to Qubic development! This guide will help you navigate the available resources and direct you to the tools you need for your specific use case.
-
-## Choose Your Path
-
-### 1. Building Smart Contracts
-
-If you want to create and deploy smart contracts on Qubic:
-
-1. **Start with the Overview**
- - Read our comprehensive [Smart Contracts Overview](smart-contracts/overview.md) to understand Qubic's unique baremetal execution model
- - Learn about IPO-based deployment and the advantages of running contracts without VMs or gas fees
-
-2. **Set Up Your Environment**
- - Follow our [Development Environment Setup](dev-kit.md) guide for Visual Studio and Qubic Core
- - Complete the [Getting Started Tutorial](smart-contracts/getting-started/setup-environment.md) for hands-on experience
-
-3. **Learn Contract Development**
- - Master the [Qubic Programming Interface (QPI)](qpi.md) - your complete guide to contract APIs
- - Understand [Contract Structure](smart-contracts/smart-contract/contract-structure.md) and [Data Types](smart-contracts/smart-contract/data-types.md)
- - Explore [Procedures and Functions](smart-contracts/smart-contract/procedures-and-functions.md)
-
-4. **Practice with Examples**
- - Study [Assets and Shares Examples](smart-contracts/sc-by-examples/assets-and-shares.md)
- - Try the [QNS (Qubic Name Service) Example](smart-contracts/sc-by-examples/qns.md)
-
-5. **Test and Deploy**
- - Use our [CLI Tools](smart-contracts/cli/Overview.md) for contract interaction
- - Follow [Testing Guidelines](smart-contracts/testing/overview.md) and access [Testnet Resources](testnet-resources.md)
-
-### 2. Building Frontend Applications
-
-If you want to build applications that interact with the Qubic network:
-
-1. **Connect to Qubic Nodes**
- - Use our [RPC endpoints](../api/rpc.md) to connect to public nodes or set up your own
- - Follow the [RPC Setup Guide](smart-contracts/rpc/setup-rpc.md) for detailed configuration
-
-2. **Integrate Wallet Solutions**
- - For complete wallet integration examples (MetaMask Snap, WalletConnect, Seed phrases, Vault files), check out the [HM25 Frontend Example](https://github.com/icyblob/hm25-frontend)
- - This repository demonstrates all key wallet connection methods
-
-3. **Use the TypeScript Library**
- - The [Qubic TypeScript Library](https://github.com/qubic/ts-library) provides tools for creating transactions and interacting with the network
- - See our [TypeScript Library docs](library-typescript.md) for installation instructions
-
-### 3. Smart Contract Interaction
-
-To interact with existing smart contracts:
-
-1. **Learn Contract Interaction Basics**
- - Check our [Frontend Integration](frontend-integration.md) guide for an overview
- - The [HM25 Frontend Example](https://github.com/icyblob/hm25-frontend) contains complete implementation examples
-
-2. **Understand Data Structures**
- - Smart contracts use specific input/output structures defined in their code
- - Find example code in the [HM25 Template](https://github.com/qubic/core/blob/madrid-2025/src/contracts/HM25.h)
-
-## Quick Reference Links
-
-- **Set up development environment**: [Qubic Dev Kit](https://github.com/qubic/qubic-dev-kit)
-- **Core implementation**: [Qubic Core](https://github.com/qubic/core)
-- **Command line interaction**: [Qubic CLI](https://github.com/qubic/qubic-cli)
-- **TypeScript development**: [Qubic TypeScript Library](https://github.com/qubic/ts-library)
-- **Wallet management**: [Qubic Vault TypeScript Library](https://github.com/qubic/ts-vault-library)
-- **Frontend example**: [HM25 Frontend](https://github.com/icyblob/hm25-frontend)
-
-## Getting Help
-
-- Join the [Qubic Discord](https://discord.gg/qubic) community for support and collaboration
-- Check for available [Qubic Grants](grants.md) to fund your project
\ No newline at end of file
diff --git a/docs/developers/library-csharp.md b/docs/developers/library-csharp.md
deleted file mode 100644
index b1342b7..0000000
--- a/docs/developers/library-csharp.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: C# Libraries
----
-
-# C# Library
-
-The C# Qubic Library provides tools to interact with the Qubic Network.
-
-For full documentation, please visit the [C# Qubic Library GitHub repository](https://github.com/qubic/qubic-csharp).
-
diff --git a/docs/developers/library-go.md b/docs/developers/library-go.md
deleted file mode 100644
index 24f0bd1..0000000
--- a/docs/developers/library-go.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: Go Libraries
----
-
-# Go Library
-
-The Go Qubic Library provides tools to interact with a blockchain-based betting system. It includes functionalities for client interactions, data type conversions, bet management, date parsing, wallet management, and cryptographic operations.
-
-For full documentation, please visit the [Go Qubic Library GitHub repository](https://github.com/qubic/go-qubic).
-
-# Go Archiver Service
-
-The Go Qubic Archiver Service's purpose is to store and make available data regardless of the current epoch.
-
-## High Level Description
-
-The archive system consists of two services:
-
-- **qubic-archiver**: The archiver processor and HTTP server that provides RPC endpoints to query the archiver.
-- **qubic-nodes**: A service responsible for providing information regarding reliable nodes and the max tick of the network.
-
-For full documentation, please visit the [Qubic Archiver GitHub repository](https://github.com/qubic/go-archiver).
-
-# Go Nodes Service
-
-The purpose of the qubic-nodes service is to continuously check node reliability and provide, upon request, a list of reliable nodes.
-
-For full documentation, please visit the [Qubic Go Nodes Service GitHub repository](https://github.com/qubic/go-qubic-nodes).
-
-# Go Node Fetcher
-
-For full documentation, please visit the [Go Node Fetcher GitHub repository](https://github.com/qubic/go-node-fetcher).
-
-# Go SchnorrQ
-
-Schnorr signature on FourQ for Qubic.
-
-For full documentation, please visit the [Go SchnorrQ GitHub repository](https://github.com/qubic/go-schnorrq).
diff --git a/docs/developers/library-http.md b/docs/developers/library-http.md
deleted file mode 100644
index c7ca992..0000000
--- a/docs/developers/library-http.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Http Libraries
----
-
-# Http Library
-
-The qubic-http service acts as a bridge to the Qubic Network. Some of its features include:
-
-- Checking balances
-- Broadcasting transactions
-- Tick information
-- Block height
-
-For full documentation, please visit the [Qubic HTTP Service GitHub repository](https://github.com/qubic/qubic-http).
diff --git a/docs/developers/library-java.md b/docs/developers/library-java.md
deleted file mode 100644
index ace7fe2..0000000
--- a/docs/developers/library-java.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: Java Libraries
----
-
-:::info
-Qubicj is a community project and not officially supported by the Qubic team.
-:::
-
-# Qubic Java Library (qubicj)
-
-The Qubic Java Library (`qubicj/qubicj-computor-api`) provides an API for developers to interact with the Qubic Network.
-
-It allows to quickly interact with the Qubic network without the need to
-know the details of the Qubic network protocol and provides features like auto node selection.
-It can be used in classic or reactive stacks.
-
-For full documentation, please visit the [Qubic Java repository](https://gitlab.com/qubic-contributions/qubicj).
-The [qubicj-shell submodule](https://gitlab.com/qubic-contributions/qubicj/-/blob/main/qubicj-shell) provides a demo on
-how to use the library in a classic Java stack with Spring.
diff --git a/docs/developers/library-rust.md b/docs/developers/library-rust.md
deleted file mode 100644
index b75ef1f..0000000
--- a/docs/developers/library-rust.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: Rust Libraries
----
-
-:::info
-qubic-utils is a community project originally created by Mineco1006 and is not officially supported by the Qubic team.
-:::
-
-# Qubic Rust Utilities (qubic-utils)
-
-The Qubic Rust Utilities library (`qubic-utils`) provides tools for developers to interact with the Qubic network using Rust.
-
-It includes:
-- `qubic-rs`: A Rust SDK to interact with Qubic Computors.
-- `qubic-rpc`: Rust wrappers and types to interact with Qubic RPC servers (like `rpc.qubic.org`) and a partially implemented server component.
-
-For the source code, examples, and further details, please visit the [qubic-utils GitHub repository](https://github.com/Mineco1006/qubic-utils).
\ No newline at end of file
diff --git a/docs/developers/library-typescript.md b/docs/developers/library-typescript.md
deleted file mode 100644
index df2d6f0..0000000
--- a/docs/developers/library-typescript.md
+++ /dev/null
@@ -1,80 +0,0 @@
----
-title: Typescript Libraries
----
-
-# Typescript Libraries
-
-## Qubic TypeScript Library
-
-The [Qubic TypeScript Library](https://github.com/qubic/ts-library) provides everything needed to interact with the Qubic network from JavaScript/TypeScript applications.
-
-### Installation
-
-```bash
-yarn add @qubic-lib/qubic-ts-library
-# or
-npm install @qubic-lib/qubic-ts-library
-```
-
-### Basic Usage
-
-```typescript
-// Import helper
-import { QubicHelper } from 'qubic-ts-library/dist/qubicHelper'
-import { QubicConnector } from 'qubic-ts-library/dist/qubicConnector'
-
-// Create helper instance
-const helper = new QubicHelper();
-
-// Create an ID Package from seed phrase
-const id = await helper.createIdPackage("your-seed-phrase");
-
-// Connect to a node
-const connector = new QubicConnector("https://rpc.qubic.org");
-
-// Get balance
-const balance = await connector.getBalance(id.publicId);
-```
-
-### Key Features
-
-- Creating and managing identities
-- Connecting to Qubic nodes
-- Fetching balances
-- Creating and signing transactions
-- Smart contract interaction
-
-For complete documentation and examples, visit:
-- [GitHub Repository](https://github.com/qubic/ts-library)
-- [Example Application](https://github.com/icyblob/hm25-frontend)
-
-## Vault TypeScript Library
-
-The [Qubic Vault TypeScript Library](https://github.com/qubic/ts-vault-library) provides tools for managing encrypted identity storage.
-
-### Installation
-
-```bash
-yarn add @qubic-lib/qubic-ts-vault-library
-# or
-npm install @qubic-lib/qubic-ts-vault-library
-```
-
-### Basic Usage
-
-```typescript
-import { QubicVault } from 'qubic-ts-vault-library/dist/qubicVault'
-
-// Create a new vault with password
-const vault = new QubicVault();
-vault.createVault("secure-password");
-
-// Add an identity to the vault
-vault.addIdentity("identity-name", "seed-phrase");
-
-// Export and save
-const vaultData = vault.exportVault();
-// Now save vaultData to file system
-```
-
-For complete vault library documentation, visit the [GitHub Repository](https://github.com/qubic/ts-vault-library).
diff --git a/docs/developers/oracles.md b/docs/developers/oracles.md
deleted file mode 100644
index 0f15634..0000000
--- a/docs/developers/oracles.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: Oracle Machines
----
-
-# Oracle Machines (OMs)
-Oracle Machines in Qubic act as a bridge between smart contracts and real-world data. They enable smart contracts to interact with external information through the Qubic Protocol Interface (QPI). These oracles, functioning as software agents, fetch real-world information and feed it into the network. Understanding Oracle Machines is crucial for writing powerful smart contracts in Qubic.
-
-Key Points:
-- Oracle Machines facilitate querying real-world data.
-- Interaction with OMs is managed via QPI.
-- OMs simplify the process of incorporating external data, allowing developers to focus on smart contract logic.
\ No newline at end of file
diff --git a/docs/developers/qpi.md b/docs/developers/qpi.md
deleted file mode 100644
index 0edddce..0000000
--- a/docs/developers/qpi.md
+++ /dev/null
@@ -1,739 +0,0 @@
----
-title: Qubic Programming Interface (QPI)
----
-
-# Qubic Programming Interface (QPI)
-
-## What is QPI?
-
-QPI stands for Qubic Programming Interface — a carefully designed and restricted programming interface used to develop smart contracts in the Qubic protocol.
-
-Unlike general-purpose C++ programming, QPI provides a safe, deterministic, and sandboxed environment that ensures all contracts behave consistently across all nodes in the Qubic network. This is essential to maintain consensus and trustless execution.
-
-## Why QPI Exists
-
-In a distributed, consensus-driven system like Qubic, **nondeterminism is dangerous**. If different nodes compute different results from the same contract call, the network breaks down.
-
-QPI solves this by:
-
-- **Restricting unsafe features** of C++ (like pointers, floats, raw memory access).
-- **Disallowing standard libraries** to avoid system-dependent behavior.
-- **Providing a strict interface** that all contracts must use to interact with the Core and with other contracts.
-
-## What QPI Provides
-
-QPI exposes a minimal but powerful set of features, including:
-
-| Capability | Description |
-| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
-| **Custom Data Types** | Use safe and deterministic types like `sint64`, `uint32`, `Array`, `BitArray`, `id`, etc. |
-| **Contract Communication** | Allows running procedures and functions of other contracts. |
-| **Asset and Share Handling** | Provides methods to issue, burn, transfer, and manage asset ownership. |
-| **Tick & Epoch Lifecycle Hooks** | Contracts can react to epoch/tick transitions via `BEGIN_EPOCH()`, `END_TICK()`, etc. |
-| **Contract Metadata Access** | Access to `qpi.invocator()`, `qpi.originator()`, `qpi.invocationReward()`, and similar context data. |
-| **Safe Arithmetic** | Built-in functions like `div()`, `mod()` to avoid division-by-zero or float precision issues. |
-| **Cryptographic Functions** | Cryptographic functionality through the K12 function, which is based on the KangarooTwelve (K12) hash algorithm. |
-| **Memory Operations** | Low-level memory operations for efficiently copying and initializing data structures in smart contracts. eg. `copyMemory()`, `setMemory()` |
-
-`qpi.h` is the Qubic Programming Interface for implementing the smart contracts. It is available automatically in the smart contract implementation header files. This page outlines the guidelines for developing secure and efficient Qubic contracts.
-Adherence to these guidelines is crucial for ensuring the proper functionality and security of your contracts within the Qubic environment.
-
-## Concepts
-
-The state is the persistent memory of the contract that is kept aligned in all nodes. A contract can have member functions and procedures.
-
-Functions cannot change the state of the contract. They can be called via a `RequestContractFunction` network message.
-
-Procedures can change the state of the contract. They are invoked by a transaction and run when the tick containing the transaction is processed.
-
-There are some special procedures that are called by the system at the beginning of the tick etc.
-
-A call of a user procedure usually goes along with a transfer of an invocation reward from the invoking user to the contract.
-
-Procedures can call procedures and functions of the same contract and of contracts with lower contract index.
-
-Functions can call functions of the same contract and of contracts with lower contract ID.
-
-Private functions and procedures cannot be called from other contracts.
-
-In order to be available for invocation by transaction and network message, procedures and functions need to be registered in the special member function `REGISTER_USER_FUNCTIONS_AND_PROCEDURES`.
-
-## Syntax and Formatting
-
-Due to security reasons, certain things are prohibited:
-
-- Declaring and accessing arrays using the C/C++ notation (`[` `]`). Utilize pre-defined array structures within qpi.h such as `collection`, `uint32_64`, `uint32_128`, ...
-- Any pointer-related techniques such as casting, accessing, ...
-- Native data types like `bool`, `int`, `long`, `char`, ... Use their corresponding predefined data types in `qpi.h` (`bit`, `uint8`, `sint8`, `uint16`, `sint32`, `uint64`, ...)
-- Inclusion of other files via `#include`. All functions must reside within a single file.
-- Math operators `%` and `/`. Use `mod` and `div` from `qpi.h` instead. `+`, `-`, `*`(multiplication), and bit-wise operators are accepted.
-- Local variable declaration, even for for-loop. You need to define all necessary variables in either in the contract state or in a "locals" struct similar to the input and output struct of a function or procedure.
-- The `typedef`, `union` keyword.
-- Floating point data types (half, float, double)
-
-Currently, the maximum contract state size is capped at 1 GiB (03/02/2024). This value is subject to change based on hardware upgrades of computors.
-
-## Member Variables and Functions:
-
-- struct `bit_x` (x = 2 ^ n, n = 1 ~ 24)
- - Member Variable
- - uint64 \_values : `x-bit` integer
- - Member function
- - bit get(uint64 index) : Retrieves the `index`-th bit of `_values`
- - void set(uint64 index, bit value) : Sets at the specified `index`-th bit to the provided bit `value`
-- struct `sint8_x` (x = 2 ^ n, n = 1 ~ 24)
- - Member Variable
- - sint8 \_values[x]; : An array of x `signed char` elements
- - Member function
- - sint8 get(uint64 index) : Retrieves the element at the specified `index`
- - void set(uint64 index, sint8 value) : Sets the element at the specified `index` to the provided `value`
-- The same goes for `uint8_x`, `sint16_x`, `uint16_x`, `sint32_x`, `uint32_x`, `sint64_x`, `uint64_x`, `id_x`.
-- struct `collection`
-
-This shows collection of priority queue of elements with type T and total element capacity L.
-
-Each ID pov (point of view) has an own queue.
-
-Array of elements (filled sequentially), each belongs to one PoV / priority queue (or is empty).
-
-Elements of a POV entry will be stored as a binary search tree (BST): so this structure has some properties related to BST(bstParentIndex, bstLeftIndex, bstRightIndex).
-
-Look at the [Binary Search Tree](https://www.geeksforgeeks.org/binary-search-tree-data-structure) to learn more.
-
-- Difference between standard BST and POV BST
-
-Each node in a standard BST has left child containing values less than the parent node and the right child containing values greater than the parent node.
-
-But each element in a POV BST has left child containing `priority` greater than the parent element and the right child containing `priority` less than the parent node.
-
-```cpp
-sint64 add(const id& pov, T element, sint64 priority)
-```
-
-Add element to priority queue of ID pov, return elementIndex of new element
-
-```cpp
-uint64 capacity()
-```
-
-Return maximum number of elements that may be stored
-
-```cpp
-T element(sint64 elementIndex)
-```
-
-Return element value at elementIndex
-
-```cpp
-sint64 headIndex(const id& pov)
-```
-
-Return elementIndex of first element in priority queue of pov (or NULL_INDEX if pov is unknown)
-
-```cpp
-headIndex(const id& pov, sint64 maxPriority)
-```
-
-Return elementIndex of first element with priority `<=` maxPriority in priority queue of pov (or NULL_INDEX if pov is unknown)
-
-```cpp
-sint64 nextElementIndex(sint64 elementIndex)
-```
-
-Return elementIndex of next element in priority queue (or NULL_INDEX if this is the last element)
-
-```cpp
-uint64 population() const
-```
-
-Return overall number of elements
-
-```cpp
-id pov(sint64 elementIndex) const
-```
-
-Return point of view elementIndex belongs to (or 0 id if unused)
-
-```cpp
-sint64 prevElementIndex(sint64 elementIndex) const
-```
-
-Return elementIndex of previous element in priority queue (or NULL_INDEX if this is the last element)
-
-```cpp
-sint64 priority(sint64 elementIndex) const
-```
-
-Return priority of elementIndex (or 0 id if unused)
-
-```cpp
-sint64 remove(sint64 elementIdx)
-```
-
-Remove element and mark its pov for removal, if the last element.
-
-Returns element index of next element in priority queue (the one following elementIdx).
-
-Element indices obtained before this call are invalidated, because at least one element is moved.
-
-```cpp
-void replace(sint64 oldElementIndex, const T& newElement)
-```
-
-Replace _existing_ element, do nothing otherwise.
-
-The element exists: replace its value.
-
-The index is out of bounds: no action is taken.
-
-```cpp
-void reset()
-```
-
-Reinitialize as empty collection
-
-```cpp
-sint64 tailIndex(const id& pov) const
-```
-
-Return elementIndex of last element in priority queue of pov (or NULL_INDEX if pov is unknown)
-
-```cpp
-sint64 tailIndex(const id& pov, sint64 minPriority) const
-```
-
-Return elementIndex of last element with priority >= minPriority in priority queue of pov (or NULL_INDEX if pov is unknown).
-
-## Core QPI Functions
-
-### qpi.invocator()
-
-The `qpi.invocator()` function returns the ID of the entity (user or contract) that directly called the current **contract procedure**.
-
-:::info
-`qpi.invocator()` returns a zero public key when called inside a function, because it is triggered by a network message and therefore has no associated entity.
-
-**Exception:** If a function is called inside a procedure, `qpi.invocator()` will return the invocator of the procedure.
-:::
-
-**Function Signature**
-
-```cpp
-id invocator() const
-```
-
-**Example usage:**
-
-```cpp
-PUBLIC_PROCEDURE(updateBalance)
-{
- // Only allow user with public key id(1,2,3,4) to call this
- if (qpi.invocator() != id(1,2,3,4))
- {
- return;
- }
- // ... proceed with logic ...
-}
-```
-
-### qpi.originator()
-
-The `qpi.originator()` function returns the ID of the original transaction sender—the entity (user or contract) that initiated the entire call chain leading to the current contract execution.
-
-:::info
-`qpi.originator()` returns a zero public key when called inside a function, because it is triggered by a network message and therefore has no associated entity.
-
-**Exception:** If a function is called inside a procedure, `qpi.originator()` will return the originator of the procedure.
-:::
-
-**Function Signature**
-
-```cpp
-id originator() const
-```
-
-**How It Differs from `qpi.invocator()`**
-
-| Function | Returns | Example Call Chain (`Alice → ContractA → ContractB`) |
-| ------------------ | -------------------------------- | ---------------------------------------------------- |
-| **`originator()`** | Original sender (first in chain) | Inside `ContractB`: `Alice` |
-| **`invocator()`** | Immediate caller (last in chain) | Inside `ContractB`: `ContractA` |
-
-**Example usage:**
-
-```cpp
-PUBLIC_PROCEDURE(updateBalance)
-{
- // Only allow direct calls from users (no intermediate contracts)
- // Rejects any calls coming through other contracts in the call chain
- if (qpi.invocator() != qpi.originator())
- {
- return;
- }
- // ... proceed with logic ...
-}
-```
-
-### qpi.invocationReward()
-
-Returns the amount of Qu (Qubic's native token) attached to the current contract call as an invocation reward.
-
-:::info
-`qpi.invocationReward()` returns zero when called inside a function, since it is triggered by a network message rather than a transaction, and therefore no reward amount is specified.
-
-**Exception:** If a function is called inside a procedure, `qpi.invocationReward()` will return the reward amount of the procedure.
-:::
-
-**Function Signature**
-
-```cpp
-sint64 invocationReward() const
-```
-
-**Paywall Protection Example:**
-
-```cpp
-constexpr sint64 FEE = 1000; // 1000 QU required
-PUBLIC_PROCEDURE(premiumFeature)
-{
- if (qpi.invocationReward() < FEE)
- {
- // user will lose 1000 QUs, because we don't give back
- return;
- }
- // Grant access...
-}
-```
-
-### qpi.transfer()
-
-Transfers QU (Qubic's native token) from the contract's balance to another address.
-
-**Function Signature**
-
-```cpp
-inline sint64 transfer( // Attempts to transfer energy from this qubic
- const id& destination, // Destination to transfer to, use NULL_ID to destroy the transferred energy
- sint64 amount // Energy amount to transfer, must be in [0..1'000'000'000'000'000] range
-) const; // Returns remaining energy amount; if the value is less than 0 then the attempt has failed, in this case the absolute value equals to the insufficient amount
-```
-
-**1. Basic Transfer**
-
-```cpp
-PUBLIC_PROCEDURE_WITH_LOCALS(sendPayment)
-{
- locals.result = qpi.transfer(input.recipientId, 1000);
- if (locals.result < 0)
- {
- return;
- }
- // Success: 'result' contains new balance
-}
-```
-
-**2. Burn QU (Destroy Tokens)**
-
-```cpp
-PUBLIC_PROCEDURE_WITH_LOCALS(burnTokens)
-{
- locals.burned = qpi.transfer(NULL_ID, input.amount);
- // burned = remaining balance
-}
-```
-
-### qpi.burn()
-
-Permanently removes QU (Qubic's native token) from circulation by burning them from the contract's balance.
-
-:::info
-In the future, contracts will be required to burn QU in order to remain active.
-:::
-
-**Function Signature**
-
-```cpp
-sint64 burn(sint64 amount) const
-```
-
-**1. Basic Token Burning**
-
-```cpp
-PUBLIC_PROCEDURE_WITH_LOCALS(burnTokens)
-{
- locals.remaining = qpi.burn(1000); // Burn 1000 QU
- if (locals.remaining < 0)
- {
- return;
- }
- // Success: 'remaining' shows new balance
-}
-```
-
-**2. Conditional Burn**
-
-```cpp
-PUBLIC_PROCEDURE_WITH_LOCALS(burnExcess)
-{
- if (state.balance > state.targetBalance)
- {
- locals.excess = state.balance - state.targetBalance;
- qpi.burn(locals.excess); // Burn surplus QU
- }
-}
-```
-
-### qpi.K12()
-
-Computes a **KangarooTwelve (K12)** cryptographic hash of input data, returning a 256-bit (32-byte) digest as an `id` type.
-
-**Function Signature**
-
-```cpp
-template - Traditional blockchains use miners to validate and add transactions to the blockchain. They compete for rewards in the form of cryptocurrency. Qubic, however, pivots to Computors that execute varied tasks and receive rewards in QUBIC based on overall participation. This distinction, including their reward mechanisms and roles, sets Computors apart from traditional miners, marking a shift in how decentralised systems might operate in the future. -
-- The `inputType` of the transaction is set to the index of the called function, and `inputSize` is set to `sizeof(inputStruct)`. The `amount` can be non-zero to simultaneously transfer qus when a smart contract function is called, and the amount is deducted from `sourcePublicKey` only if the function is called. -
-- Data from the input struct are injected between `inputSize` and the signature. If not enough data is supplied, the remaining portion is filled with zeros. If the data exceeds the actual input data, then the input is truncated. -
-- Every new smart contract on Qubic requires an Initial Public Offering (IPO). This is not just a fundraising exercise but also a mechanism to control the QU supply. All $QUBIC spent during the IPO's Dutch auction will be permanently burned, ensuring a continuous reduction in the active supply of $QUBIC over time. -
-- In Qubic, we take a unique approach to mining through our 'Useful Proof of Work' (UPoW) system. A fundamental component of this approach is the utilization of artificial neural networks (ANNs), a model inspired by the human brain's own network of neurons. -
-- Since the inception of ANNs, the objective has been to replicate the complexity and functionality of the human brain as closely as possible. While some researchers have chosen to mimic the sophisticated neuron activation function, which requires intricate mathematical models, we have focused on replicating the structural changes that occur in a developing brain. -
-- If you think back to the early years of life, you'll realize that while the basic functionality of neurons remained the same, your mental abilities greatly improved. This development can largely be attributed to the increase in connections between neurons. -
-- Research suggests that initialising an ANN with random parameters results in an entity possessing some primitive cognitive function. In fact, an ANN where all neurons are interconnected already has some degree of memory and intellect. The process of improving an ANN is actually a process of eliminating connections - up to a point. There's a 'sweet spot' where an ANN of a certain size demonstrates the best intellectual abilities. Beyond this point, further elimination of connections leads to degradation. -
-- In Qubic, miners don't follow a path of destruction but instead generate ANNs with a random structure of connections. These parameters are changed, and Aigarth analyses the properties of the ANNs. The current stage involves collecting samples and trying to discern patterns that may provide insight into the future direction of development. This process reflects Qubic's unique approach to utilising ANNs and creates a mining process that is not only computationally challenging but also contributes to the development of these neural networks. -
-{description}
-{description}
-{description}
-Explore our APIs to build powerful integrations with the Qubic network.
-