Geeq

GEEQ (GEEQ) is a multi-blockchain platform secured by our Proof of Honesty TM (PoH) protocol, secure enough for your most valuable data, cheap enough for IoT, and flexible enough for any use.

Blockchain can provide society with secure, uncensored and decentralized ways to interact, transact and collaborate. As a source of provable and immutable truth, the blockchain allows widely distributed agents, including machines that do not know or trust each other, to create and share value. Blockchain can even serve as a counterbalance to the growing power of governments, corporations, and other centralized authorities.

Unfortunately, blockchain technology has a long way to go before it can realize this potential. Existing platforms are not very secure, expensive and difficult to use, and difficult to deploy at any meaningful scale. The extreme volatility seen in the crypto markets has undermined public confidence in their value as a form of payment and, even more so, as a safe store of value. Thousands of public infrastructure and distributed application ( DApp ) projects are underway or already launched. However, the vast majority of transaction volumes are simple payments on the Ethereum and Bitcoin networks or private permissioned platforms such as Ripple and IBM Fabric.

Geeq's goal is to take the public blockchain to the next level. We propose a new blockchain consensus protocol called Proof of Honesty (PoH) that treats users as the ultimate source of authority and truth, rather than allowing that authority to reside in the nodes of the validation network. Proof of Honesty is 99% Byzantine Fault Tolerant (BFT) and gives Geeq Strategically Provable Security (SPS), a guarantee based on non-cooperative game theory. In contrast, blockchains using Proof of Work (PoW), Proof of Authority (PoA), Proof of Stake (PoS) can only offer 33% to 50% BFT. This is simply not enough if critical infrastructure, personal and financial data, stock exchanges or public records are to be trusted on blockchains. It's even less acceptable

Geeq's interoperable multi-chain architecture allows geeqchains to be customized and optimized for a wide variety of use cases. Geeqchains include a flexible application layer that can be designed to follow almost any business logic and have its own native tokens and data types. Native tokens and data can be transferred to affiliated geeqchain instances or stored in the instance they were created from. The Geeq verification layer is completely separate from the application layer, and each geeqchain instance has its own independent verification network.

When there is a central party that can and should be trusted with data, there is no real need for a blockchain. Employers keep personnel records in private databases, and manufacturers likewise keep records of inventories, sales, parts, payables, and so on. And that's how it should be. Similarly, if multiple parties trust each other, such as a consortium of banks or hospitals, then synchronized data systems do a great job.

There are five key criteria that make it likely that blockchain, as opposed to more traditional distributed data systems or software as a service (SaaS) cloud solution, is the best approach to solve the problem:

1. The problem requires a secure transfer of value, perhaps in very small increments; for example, micropayments for content or web services and machine-to-machine markets, as well as individual payments such as small charitable contributions or sharing the cost of a meal among a group of friends.

2. The problem is with agents who don't know or trust each other; for example, peer-to-peer markets for goods and services, escrow, and providing proof that all parties are acting as they say and behaving with integrity.

3. The problem affects many different actors from different organizations whose interests do not coincide; for example, logistics or supply chain applications that transfer responsibility from party to party.

4. The problem requires the objective provability of facts or data; for example, audit logs and telemetry collected from connected industrial, medical, and infrastructure devices.

5. The problem is related to agents who may want to censor, change or hide data; for example, securities, land ownership, and financial transactions where theft and fraud are a real possibility.

For a blockchain to offer a viable solution to these problems, it must be secure, inexpensive, and scalable. For blockchain as a service (BaaS) to become a viable alternative to private databases, it must be flexible, upgradable, environmentally sustainable, and protect users from unreasonable token price volatility.

Geeq provides the answer to all these problems. Let's start by describing what Geeq is. An instance of a geeqchain is any blockchain that uses Geeq's verification protocols and architecture (as described below). The set of all instances together form an ecosystem of separate but interacting blockchains that make up the Geeq platform. Each geeqchain extends from its own genesis block created by Geeq, which guarantees the integrity and security of the instance.

All geeqchain instances start with a genesis block (block number 0). Blocks of verified transactions are created by nodes in the network and added sequentially. Genesis blocks are created by Geeq at the request of developers who want to build applications and include all the code that will run the validation and application layers. There are several reasons for this tight control over the shape of genesis blocks.

-This prevents duplicate chain and token names.

-This ensures that the chain adheres to Geeq's protocols for validating transactions, which in turn allows different instances to trust each other's ledger integrity and accept token transfers from other geeqchains.

-Most importantly, it sets the rules by which the network will operate. Including copies of the validation code and DApps that nodes must use in the genesis block allows users to conduct their own audits to make sure the rules are being followed and the nodes are behaving honestly.

Geeq's founding principle - Code is law. If the blockchain protocol or ledger can be changed by funds, governance systems, collective actions of nodes, etc., then the blockchain is neither immutable nor unreliable. Instead, users must trust the wisdom and good faith of those who are truly in control.

It may seem that this approach gives Geeq great opportunities. However, once a genesis block is created, neither Geeq nor anyone else can change it or the operation of the geeqchain instance that uses it as a basis. There is simply no mechanism that allows such manipulations to be performed. Once launched, each geeqchain takes on a life of its own.

Bugs, hacks, updates, new features, quantum computing, etc. all make it desirable to be able to allow blockchains and DApps to evolve and change over time. When hard forks 6 are forced on unwitting or unwitting users by foundations, developers, node coalitions, or even through complex governance systems, user trust is lost and trust in the platform is undermined.

Geeq's multi-chain architecture provides an elegant solution to this problem without violating our core principle that code is law. If a geeqchain instance is found to have bugs, is outdated, does not take advantage of new technologies, or does not meet current user requirements, a new instance may be created with the intent to replace the existing one. The new chain will have a new genesis block with a new set of validators, validators, and application code, but no tokens. Users and validators on the old chain can choose to move to the new chain, where the rules are different, or stay where they are. If they decide to move their tokens, their actions will be voluntary and within the protocol. If they decide to stay, they can continue to live by the old rules.

It won't be long before quantum computers can break 256-bit (or more) encryption. This will undermine the security models of all existing blockchains and pretty much everything else in the cloud. Fortunately, with quantum computing approaches to breaking encryption, new quantum-resistant approaches to data encryption will emerge. Geeq's multi-chain architecture allows for the creation of new quantum-ready instances of existing chains and applications that users can migrate to as quantum technology advances.

Blockchains are built on networks of nodes that process, validate, and store transactions. Geeq shares this foundation, but builds on it for a uniquely secure and resilient ecosystem.

In fact, Geeqchains consist of two completely separate blockchains and ledgers that are served in parallel by the same network of validating nodes. This unique two-tier approach allows Geeq to be flexible and adaptable without sacrificing security.

The Geeq verification level is simple and reliable. It contains only $GEEQ accounts and manages the underlying token transactions between users, as well as paying fees to nodes for their validation and virtual machine services.

On the other hand, the Geeq application layer is configurable and can support business logic, smart contracts, DApps, native tokens, and specialized data elements to suit almost any use case. For example, the application layer of a geeqchain instance can be configured to run Solidity and allow smart contracts originally written to run on Ethereum to be moved directly to Geeq.

The functionality will be the same, and the data formats and blockchain created at the application level will look almost the same as in Ethereum. The difference will be that payments between users and nodes for transaction fees will be recorded on the verification layer blockchain. It could also be possible to create a simple (non-Turing complete) application-level scripting language, or even just code to run one particular application, if that were all the developer needed.

Geeq's two-layer approach minimizes attack surfaces because the verification layer does not have smart contracts or other complex features. At the same time, the application layer allows developers to create exactly what they need without migrating items they don't need in a ledger that is independent of the underlying validation protocol and blockchain.

Geeq is also taking a new approach to creating and maintaining network nodes that verify each geeqchain instance. Anyone can download the Geeq node client software and then anonymously join one of the verification networks by sending a "join active node list (ANL)" transaction to an existing node. The join transaction includes an IP address at which the node can be contacted and authorization to transfer a certain amount of $GEEQ from the new node's account to an escrow account as a Good Conduct Binding (GBB). ANL is maintained as part of a ledger that tracks user account balances. As a result, users can find out where to contact all nodes in any given inspection network by requesting an ANL from any node.

Bitcoin, Ethereum, and most other blockchains use peer-to-peer gossip networks to relay user transactions, distribute newly mined blocks, and relay other message traffic between nodes. In the case of bitcoin, for example, users find the IP address of a node and send it a transaction request. This request is then broadcast to a group of peers known to the receiving node, and from there it propagates to the rest of the nodes in the network. This is called a "network of gossip", as messages are passed from node to node until they are known to the entire network. As a result, messages can be resent to peers that have already received them from other peers. The time it takes for a message to find its way to all members of the network is random and may not be trivial. For example,

Geeq uses a hub and spoke instead of a gossip network structure. A hub and spoke is more efficient than a gossip network because it transmits the smallest possible set of messages and allows them to reach the entire network faster. Each node serves as a hub for one block and then passes the job to the next node in the queue. For example, a network of nine nodes with node number eight acting as a hub would look like this:

The geeqchain genesis block encodes it with the ability to customize its own public hub and network of validators to suit your needs.

To summarize:

-There is no master chain or central point of failure in the Geeq ecosystem.

-Geeq is a public, permissionless blockchain platform verified by anonymous nodes that can join or leave any given verification network at will.

-Each geeqchain instance has its own independent set of validators and supports validation layers and applications with separate blockchains.

-Any number of geeqchain instances can be created, allowing the ecosystem as a whole to scale to process the required number of transactions per second (TPS).

-Geeq is a network of networks that form an ecosystem of interacting blockchains.

-$GEEQs can be freely transferred across all chains of the ecosystem, and applications can be designed to interoperate as needed. With

There is an elegant way to update that does not penalize users. If users find a better alternative, they can vote with their feet.

Geeq also uses a completely different chaining and ledger approach than existing protocols. It starts with the Geeq workflow:

1. The user selects any node in the chain verification network that he wants to use and sends him a transaction request.

2. Nodes wait for transactions to arrive (ten seconds by default) and then group those requests into a node transaction bundle (NTB), generate a header, and cryptographically sign the whole thing with their private keys.

3. Nodes send these non-tariff barriers to the current hub.

4. The hub groups these NTBs together into a Hub Transaction Bundle ( HTB ), signs it with its private key, and then sends the HTB back to each of the nodes.

5. Each node separately and independently considers each candidate transaction in the HTB and builds the next block in the chain from those that it considers valid.

6. Each node updates its view of the current state of the ledger ( CLS ) using its block of valid transactions.

7. Meanwhile, the nodes are receiving new transaction requests from users. Once each node commits its block, it creates another NTB and sends it to the node acting as the hub to coordinate the building of the next block.

hree things should be emphasized here:

-Each node gets exactly the same set of HTB candidate transactions to evaluate for each block.

-If each node starts with the same CLS and considers the same set of candidate transactions, they should all come to the same conclusions about which transactions are valid, what the next block is, and how it updates the CLS to move to the next ledger state . If nodes come to different conclusions, then some nodes must be dishonest.

-The header of each NTB must include the host's hash of the CLS representation and the valid block just created. Below we will see why this is important.

Proof of Work consensus protocols select a block proposer or leader in a cryptographic race to solve a check-and-guess puzzle. The nodes "mine" the block, spending huge computing resources on finding a solution (the so-called "one-time number"). The first node to solve the puzzle broadcasts its block to other nodes through the gossip network. If a node (called a “miner”) receives a valid and correctly mined block, it must stop working on its own block, commit the newly mined block to the chain, create a new candidate block with the correct transactions, and start the mining process over again. Only the successful miner receives transaction fees and mining rewards.

Proof of Stake consensus protocols use voting mechanisms to decide whether a proposed block should be pegged to an existing chain. Leader selection methods and voting rules vary, but the most common approach is to give nodes different voting weights in proportion to the share of the token base they hold or have delegated to them by other nodes. Thus, richer nodes have more influence on block commits. In almost all cases, a two-thirds rate-weighted vote is required to approve a block.

Geeq takes a fundamentally different approach. First, there are no leaders or block proposers in the Geeq protocol. The hub coordinates block building by collecting and distributing the NTBs submitted by the nodes, but does not select a set of candidate transactions from the memory pool or elsewhere. In addition, the hub does not validate transactions in its HTB and does not offer a lock for other nodes to commit. Second, nodes do not vote for HTBs or blocks in any way. Instead, each node decides for itself which transactions in the HTB it considers valid, what the next block should be, and how it should update the state of the ledger.

Of course, for a blockchain to have any use, there must be agreement on the state of the ledger and the set of valid transactions that led to it. In other words, there must be a canonical ledger state that honestly reflects the canonical chain of valid blocks and transactions. Geeq achieves this with a layered security model.

The first layer of security encourages nodes to control themselves through a game-theoretic mechanism called the catastrophic disagreement mechanism (CDM). To understand how this works, remember that nodes must deposit the hashes of their new blocks and CLS in NTB, which they send to the hub in the next round. If all nodes are honest, all nodes will come to the same correct conclusions. The only way for a node to come to a different conclusion is to be dishonest and deviate from protocol. Honest nodes will immediately see from the NTB that certain nodes were dishonest because the block and CLS hashes were different from their own. CDM allows honest nodes to record an audit against unscrupulous nodes and collect their GBB as a reward. This simple mechanism gives us two great things:

-If at least one node is honest, it will record an audit against unscrupulous nodes, collect them by GBB, and remove them from ANL in its version of the registry. More importantly, there will be a fair and correct version of the blockchain and CLS (along with many other versions that may be incorrect and dishonest). Again, we'll see why this is important below.

-Honest behavior (meaning that all nodes strictly follow the protocol) is a "stable coalitional equilibrium". In other words, validating honestly and following the protocol gives nodes a higher payoff than any alternative strategy available to any coalition of validators, including the grand coalition (all nodes act together). Moreover, universal honesty is the only sustainable coalition equilibrium. Thus, CDM provides what we call Strategically Served Security (SPS). This is much stronger than the "Nash equilibrium", which only protects against deviations (in this case, dishonesty) of individual nodes acting alone.

The second layer of security makes users, not nodes, the final arbiter of the correctness of transactions, blockchains, and ledger states. Well-designed blockchains are auditable in the sense that if an observer has access to the history of the chain going back to the genesis block, he can compute the correct CLS himself. Thus, any observer with sufficient information can prove to himself whether the representation of the chain and ledger maintained by the node is honest or dishonest. The problem is that there is nothing the user can do if they find that the node is dishonest according to existing protocols. If most of the hash power or most of the stake decides to approve the wrong transactions and add them to the confirmed blocks, the user can either accept false,

Geeq uses an innovative protocol called Proof of Honesty (PoH). It works like this: users interact with geeqchains through a "custom client". This is a software application that makes Geeq easier to use, but also allows users to protect themselves from dishonest behavior. When a user wishes to make a transaction, their client contacts the node and requests an ANL. The user client then randomly selects a node from the ANL and sends it a request to confirm that it supports the honest geeqchain. If the node is honest, it sends the proof, the user client verifies it, and the user submits the transaction. If the node cannot or refuses to prove its integrity, the client tries another node.

PoH seems simple, but the effect is significant:

-Assume that at least one node is honest and therefore writes an honest chain and ledger. Since any agent can determine if a node is honest, why would a rational user accept tokens in a dishonest ledger if an honest one exists? Such tokens have most likely been stolen and can be stolen from any user who accepts them. In this way, users who allow their clients to work in their interests will never be deceived into accepting payments on dishonest and therefore invalid ledgers. As a result, dishonest registries and the tokens they contain are worthless. Trying to transact with a provably invalid ledger would be like trying to pass off a $100 bill scrawled on a cocktail napkin as real.

-PoH is 99% BFT. That is, if there is at least one of the honest nodes, users will find it and will send and receive transactions only in the registry that it maintains. Unscrupulous registries and hosts will be ignored. This is why one or a small minority of honest nodes can enforce whatever checks they have on bad nodes and benefit from the GBB confiscated. The Geeq protocol does not require the votes of unscrupulous nodes to approve transactions or blocks.

-Each node is given the same set of transactions, its block chains and ledgers are stored, and tools are then provided to users to verify evidence of whether the node is acting honestly.

To summarize:

-Geeq has no leaders or blocking proposals. Each node decides for itself what the correct block and registry is, and each user can prove to himself whether this or that node is the correct representation. Thus, security comes from the edge, not from the center. Users, not nodes, are the final arbiters of truth.

-CDM is an audit mechanism that implements fair behavior in a stable coalition equilibrium.

-PoH does not require the majority of hash participants to be honest. Only one honest node is required. So PoH is 99% BFT instead of 50% or 33% like other protocols.

There are several unanswered questions here. For example: what to do if all nodes are dishonest? What incentive do nodes have to expend the resources needed to create and send proofs of integrity, NTBs, and HTBs as required by the protocol? How does Geeq prevent forks and deal with partitions? These issues are addressed by additional layers of security, which are discussed in detail in our White Paper.

Geeq offers unparalleled security, unlimited transaction capacity, and exceptional flexibility at a very low cost.

Transactions on Geeq are very inexpensive. This is mainly because the proof networks are relatively small, the networks are efficient, the message and record formats use minimal memory and bandwidth, the stakes required for nodes to participate are low, and Proof of Work does not consume electricity or computation cycles.

Geeq is a low cost, reliable, interoperable multi-chain platform. Its architecture allows Geeq to scale without limits at a transaction cost of 1/100 of 1 cent.

Limitless scalability at low transaction costs allows Geeq to use its comparative advantage in blockchain security to create several new markets, discussed in Section 6 below. The Geeq platform was designed with the following practical considerations in mind.

Network Size: Using more nodes results in higher costs and lower TPS.

-Bitcoin and Ethereum have many thousands of nodes in their networks, each running expensive proof of work.

-PoS has many variations. In some cases, stake is delegated by token holders to fewer voting nodes. In this case, only a few nodes are actually involved in verifying transactions and exchanging data on the network. Others, such as Algorand, require all users to be willing to participate in the verification network.

-One geeqchain instance can handle 40-200 TPS depending on available bandwidth and network configuration.

The maximum tps of the Geeq platform using the current technology is 200xN, where N = the number of geeqchains on the platform at the moment.

TPS: transactions per second.

-Since any number of geeqchain instances can be created, the transaction processing capabilities of the Geeq ecosystem are unlimited.

-PoW blockchains typically have large networks and large computational loads. As a result, TPS is low, typically 2-25 TPS.

-PoS systems with small networks can reach several hundred TPS and even more if they are running on cloud servers that provide them with unlimited bandwidth.

-All protocols known to us have either one block chain (or DAG) or one master chain. While transactions can be sent quickly, these structures inherently have more difficulty growing in volume. On the contrary, Geeq is a truly decentralized -system of interacting blockchains.

Transaction costs:

-The resources used by a geeqchain instance are very small and roughly proportional to the size of the checknet that the instance is using. The cost of computing resources is from 1/1000 to 1/100.

-PoW blockchains must pay the cost of the large amount of electricity used to validate the ledger. In addition, such block chains are slow, which creates a shortage of slots for transactions. In turn, this forces users to offer high fees to get their transactions included in the next block.

-There is such a variety of approaches to PoS that it is difficult to draw general conclusions about transaction fees. However, users ultimately have to pay validators for the opportunity cost of locking tokens to gain a share of the vote and for the costs incurred by the network. Together they can be significant and in any case more than the cost of running a geeqchain instance.

-Some public DAGs such as Iota state that they do not charge transaction fees. However, the graph they create is a very large piece of data, and users must know a significant portion of it to know that the transaction is valid and complete. - As a result, to ensure sustainability, these non-trivial costs must be covered by the users of the system either through transaction fees or through network resources.

-Private DAGs and PoA blockchains can be relatively inexpensive in terms of compute, bandwidth, and storage resources. Often the validation networks that support them are relatively small. However, such proprietary solutions may incur significant installation, licensing fees, and ongoing support costs.