# Project Introduction

Plater Network is an independent enterprise and privately held company with a noble objective of building the decentralized technology of information flow and data transferring software. The entire network will be based on the blockchain technology, which increases the number of benefits for users. The idea of creating Plater Network came up in 2019 and the company was officially registered in 2022. It is now in the development process of building and polishing the application.

The main objective is to develop an information flow software based on blockchain technology to prevent surveillance and influence of third-party entities on vulnerable information. It will be our small contribution to shape a bright and more equal future. The concept is based on the transactions settled between particular nodes. Sender and receiver are the nodes in this case together with a validation node who confirms the transaction. The usage of Interplanetary File System was rejected to provide independent Plater Information Flow System. The sender uploads the file, document, or information. This information gets encrypted and the document hash is assigned. After verification of the transaction accordance and keys of both, sender and receiver the information can be securely transferred through the blockchain.


# Disclaimer

#### **Disclaimer**

This documentation is intended to provide an overview of the **Plater Network** software, outlining its primary features, structure, algorithms, and technical implementations. The information contained herein is developed based on the current understanding and intended design of the software, which remains under active development and continuous improvement.

While we strive to ensure accuracy and clarity, please note the following:

**Development Status**: The Plater Network software is still in development, and as such, functionality, code snippets, and architectural descriptions in this document are subject to change. Features, methods, and algorithms discussed may evolve as testing progresses and new requirements emerge.

**Potential Errors and Omissions**: Due to the ongoing nature of development, there may be unintentional errors, outdated information, or oversights in the documentation. Users and developers are encouraged to treat this as a general guide rather than a comprehensive or final representation of the system.

**Security and Stability Risks**: As with any decentralized system in active development, certain components of the network may pose security or stability risks until thoroughly vetted and tested. Developers should exercise caution when implementing or relying on any code provided here.

**Liability and Usage**: The Plater Network team does not accept liability for any loss, damages, or issues arising from reliance on this documentation or code implementation. Use of the software and any related components is at the user’s own risk.


# Overview

**Introduction:**

The PLATER Network is designed as a decentralized platform leveraging blockchain technology to facilitate secure, transparent, and efficient interactions within a tokenized ecosystem. The main objectives are:

* **Transparency**: Ensuring all actions within the network are verifiable and publicly accessible.
* **Security**: Protecting user data and transaction integrity using cryptographic protocols.
* **Scalability**: Allowing the network to handle a large number of transactions efficiently.

PLATER achieves these objectives by incorporating mechanisms such as staking, tokenized incentives, and a modular architecture that allows seamless scalability as the network grows.


# Plater Information Flow System

The **Plater Information Flow System (PIFS)** manages data flow within the network, allowing secure data transfer between nodes with distinct roles.

Plater Information Flow System being designed as an internal algorithm that is being used to distribute, flow, and share the data with use of blockchain technology. It involves all the aforementioned and the further mentioned concepts that will be the foundation for a seamless process of data and information flow within Plater Network. Understanding the transaction functioning and design is crucial, and was therefore explained below in a graphical method. Plater Information Flow System (PIFS) is simplified and minimizes the risk of data leaks. It ensures reinforced data protection thank to the use of compounded hashing and encryption methods. What is more, the decentralized nature of the network adds to the protection and provides a robust network that assures a liquid flow of information.

The transaction process involves a few governance roles and nodes. The concept of Plater Network and its information flow system works as follows: User1 of the network decides to send the information to User2. User1 uploads files (documents, information etc.) to the network. Thanks to the plotting and mining, the storage is secured and cannot be used in other purposes than data transfer. Nodes have unique addresses. Therefore, the transaction can be requested. The validator accepts the request, and the transaction can be settled. It gets encrypted to ensure the highest security, and the information hash is assigned. User2 successfully receives the information directly to his claimed hardware storage, and then it may be safely opened locally on the device. Please, see the diagram below for better understanding of the functionality.

1. **Sender Node**: Encrypts data and submits it to the network for storage.
2. **Validator Node**: Validates and authenticates the data, ensuring integrity without requiring access to the actual data.
3. **Receiver Node**: Decrypts and accesses data upon retrieval, ensuring authorized access only.


# Data Security and Encryption

\*This is sample solution to be tested\*

**Merkle Tree Hashing for Data Verification**

A Merkle Tree provides efficient data integrity checks, requiring minimal computation to verify a data segment against a root hash. This allows for rapid verification while keeping data accessible.

```solidity
function verifyCalldata(
    bytes32[] calldata proof,
    bytes32 root,
    bytes32 leaf
) internal pure returns (bool) {
    return processProofCalldata(proof, leaf) == root;
}

function processProofCalldata(
    bytes32[] calldata proof,
    bytes32 leaf
) internal pure returns (bytes32) {
    bytes32 computedHash = leaf;
    for (uint256 i = 0; i < proof.length; i++) {
        computedHash = _hashPair(computedHash, proof[i]);
    }
    return computedHash;
}
```

**SHA3 Hashing for Security**

The **SHA3** cryptographic hash function generates a unique identifier for each transaction, ensuring data uniqueness and security. SHA3 produces a fixed-size output that’s highly sensitive to input changes—any alteration in the data drastically changes the hash, making tampering detectable.

**Mathematical Basis:** *SHA3* produces a fixed-size output:

*H(M)=SHA3(M)*&#x20;

For a message *M*. Minor changes in *M* create distinct hash outputs, maintaining the integrity of each transaction.

```solidity
import sha3 from 'solidity-sha3';

// Example usage
sha3('a'); // Produces unique hash
sha3('0x0a'); // Another unique hash output
```


# Consensus Algorithms

\*This is sample solution to be tested\*

**Proof of Stake (PoS) Mechanism**

PoS allows validators to stake PLATER tokens, securing the network and incentivizing validators based on their stake.

```solidity
function stake(uint256 amount) public {
    require(balances[msg.sender] >= amount, "Insufficient balance.");
    stakes[msg.sender] += amount;
    totalStaked += amount;
}

function calculateProbability(address validator) public view returns (uint256) {
    return stakes[validator] * 1e18 / totalStaked;
}
```

**Proof of Capacity (PoC) Nonce Generation**

Nodes commit storage for fast block production by precomputing hash scoops, defining time limits for block creation.

```solidity
function calculateDeadline(uint256[] memory scoops) public pure returns (uint256) {
    uint256 minDeadline = scoops[0];
    for (uint256 i = 1; i < scoops.length; i++) {
        if (scoops[i] < minDeadline) {
            minDeadline = scoops[i];
        }
    }
    return minDeadline;
}
```


# Main features

**Peer-to-peer network**

The use of distributed network enables users to directly send data, files, and documents between each other. This means that information sent is not stored in any physical place but held by each network user (node). Each file has its unique cryptographic hash. When a user from requests to share/receive data the network finds the nodes holding a perfect match to the unique hash or hashes and the transaction is successful.

**Permanent and immutable**

Usage of a decentralized network across multiple users provides immutable and permanent transaction because when the transaction is approved (validated by other users of the network) the data cannot be changed.

**Surveillance and censor resistant**

The core objective of Plater Network is to exclude third-party services from personal transactions as it takes place now. It will help to send confidential information without any influence or interference of out-of-network entities and improve the reliability of the information.

**Fast and secure**

The transactions are highly secure and time effective. Transactions are quickly verified by the other nodes. Then, additionally linked to the previous block and secured with 1024-bit key encryption and 7 tokenization, which makes it almost impossible to hack or manipulate. Because the transactions are being settled between nodes the whole process is very fast.

**Open source**

All the information and documentation give a clear overview of the technology and enables other people to use it without any restrictions. All the new updates and changes will always be publicly available. Plater's open-source software will be always public and accessible to everyone. It increases transparency, scalability, and expansion of the network.

**Cost effective**

The company will charge a small fee for using its software. However, Plater Network guarantees the best price on the market and all the charges have algorithmic nature. The token which will give access to the network. It may be acquired through the exchange or by staking.


# Token Implementation

Below the technical information can be found in regard to the Plater Token and major details concerning the smart contract built to develop the token of Plater Network.

NOTES:

* The following specifications use syntax from Solidity 0.5.16 (or above)
* Callers MUST handle false from returns (bool success). Callers MUST NOT assume that false isnever returned!

1\. Methods&#x20;

1.1 name

```solidity
       function name() public view returns (string)
```

• Returns the name of the token – In this case: "Plater".&#x20;

1.2 symbol

```solidity
function symbol() public view returns (string)
```

• Returns the symbol of the token. In this case: “PLATER”.&#x20;

1.3 decimals

```solidity
       function decimals() public view returns (uint8)
```

• Returns the number of decimals the token uses - e.g. 8, means to divide the token amount by 100000000 to get its user representation.

1.4 totalSupply

```solidity
       function totalSupply() public view returns (uint256)
```

• Returns the total token supply. The token flows across BNB Smart Chain only therefore, the number will never be multiplied.

1.5 balanceOf

```solidity
function balanceOf(address _owner) public view returns (uint256 balance) 
```

• Returns the account balance of another account with address \_owner.

1.6 getOwner

```solidity
function getOwner() external view returns (address);
```

• Returns the Plater Token owner.&#x20;

1.7 transfer

```solidity
function transfer(address _to, uint256 _value) public returns (bool success)
```

• Transfers\_valueamount of tokens to address\_to, and MUST fire the Transfer event. The function SHOULD throw if the message caller’s account balance does not have enough tokens to spend.

1.8 transferFrom

```solidity
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)
```

* Transfers \_value amount of tokens from address \_from to address \_to, and MUST fire the Transfer event.
* The transferFrom method is used for a withdraw workflow, allowing contracts to transfer tokens on your behalf. This can be used for example to allow a contract to transfer tokens on your behalf and/or to charge fees in sub-currencies. The function SHOULD throw unless the \_from account has deliberately authorized the sender of the message via some mechanism.

1.9 approve

```solidity
function approve(address _spender, uint256 _value) public returns (bool success)
```

• Allows \_spender to withdraw from your account multiple times, up to the amount. If this function is called again, it overwrites the current allowance with .

1.10 allowance

```solidity
function allowance(address _owner, address _spender) public view returns (uint256 remaining)
```

• Returns the amount which \_spender is still allowed to withdraw from \_owner.&#x20;

2\. Events

2.1 Transfer

```solidity
event Transfer(address indexed _from, address indexed _to, uint256 _value)
```

• MUST trigger when tokens are transferred, including zero value transfers.\
• A token contract which creates new tokens SHOULD trigger a Transfer event with the \_from address set to 0x0 when tokens are created.

2.2 Approval

```solidity
event Approval(address indexed _owner, address indexed _spender, uint256 _value) 
```

• MUST trigger on any successful call to approve(address \_spender, uint256 \_value).


# Nodes

\*This is sample solution to be tested\*

**Node Responsibilities with Incentive Calculations**

**Storage Node Incentives**:

* Rewards depend on storage commitment and duration.
* **Reward Formula**:

*Reward=base reward×storage capacity×duration*

```solidity
function calculateReward(uint256 baseReward, uint256 storageCapacity, uint256 duration) public pure returns (uint256) {
    return baseReward * storageCapacity * duration;
}
```


# Tokenomics

#### Allocate Token Supply

Using the categories above, we can distribute the 120,000,000 PLATER tokens as follows:

| Category                              | Percentage | Token Allocation  | Notes                                                       |
| ------------------------------------- | ---------- | ----------------- | ----------------------------------------------------------- |
| **Fundraising**                       | 22.5%      | 27,000,000 PLATER | Raises funds to support project development                 |
| **Company Reserves**                  | 12,5%      | 15,000,000 PLATER | For future development and stability                        |
| **Team Allocation**                   | 10%        | 12,000,000 PLATER | Vesting schedule to align with project growth               |
| **Strategic Partnerships**            | 10%        | 12,000,000 PLATER | To build ecosystem alliances                                |
| **Network Maintenance & Development** | 20%        | 24,000,000 PLATER | For ongoing upgrades, R\&D, and maintenance costs           |
| **Exchange Listings & Liquidity**     | 10%        | 12,000,000 PLATER | To ensure liquidity for trading on exchanges                |
| **Staking Rewards & Incentives**      | 15%        | 18,000,000 PLATER | To reward participants, ensure network security, and growth |


# Roadmap

**Q4 2024**

**New Website Reveal**

* **Website Update**: Launch a redesigned website featuring new objectives and a fresh look for Plater Network.
* **Community Feedback**: Gather feedback from the community on the new site to refine and enhance its user experience.

***

**Q2 2025**

**Initial Coin Offering (ICO)**

* **ICO Launch**: Kick off the initial coin offering to secure funding for network development and scaling.
* **Community Building**: Engage with early supporters and investors via online forums, events, and outreach.

***

**Q3 2025**

**Strategic Partnerships**

* **Partnership Formation**: Build alliances with industry leaders to advance technological innovation.
* **Collaboration Agreements**: Sign partnerships to integrate advanced security and data privacy tools.

***

**Q1 2026**

**Security Audit and Software Development**

* **Security Audit**: Conduct a thorough audit of the $PLATER token and platform, verified by third-party experts.
* **Software Development**: Begin implementing key Plater Network features, incorporating feedback from initial audits.

***

**Q3 2026**

**Testing on Testnet**

* **Testnet Launch**: Release the Plater Network on a testnet environment for intensive testing and validation.
* **Bug Fixes and Optimization**: Address bugs, enhance performance, and gather testnet user feedback for improvements.

***

**Q4 2026**

**Mainnet Deployment**

* **Mainnet Launch**: Launch the Plater Network on the mainnet, opening it up to early adopters.
* **Initial Rollout**: Initiate a phased rollout of key features to ensure a stable transition from testnet to mainnet.

***