feat: add fantom chain documentation (#43)

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- **New Features**
- Introduces an overview of Fantom, including key features like FTM
cryptocurrency and Lachesis consensus mechanism.
- Information on different node types within SettleMint for blockchain
history maintenance.
- Guide on connecting to a blockchain node using various backend APIs.
    - Dashboard displaying network statistics of the Fantom network.
- SettleMint IDE for editing smart contracts with features like OpenAI
GPT integration.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: SaeeDawod <122533407+SaeeDawod@users.noreply.github.com>

Author: insider89

docs/blockchain-guides/11_Fantom/1_fantom-the-basics.md

@@ -0,0 +1,25 @@
+# The basics
+
+Fantom is a high-performance, scalable, and secure smart-contract platform launched in December 2019. It is designed to overcome the limitations of older blockchain platforms like Ethereum. Fantom’s native cryptocurrency is called FTM. The platform leverages a unique consensus mechanism known as Lachesis, which allows it to process transactions much faster and at a lower cost compared to traditional blockchains. Fantom is fully compatible with the Ethereum Virtual Machine (EVM), enabling developers to deploy their existing Ethereum dApps on Fantom without any changes. Beyond scalability and compatibility, Fantom emphasizes decentralization. The network is secured by a decentralized network of validators and governed through on-chain governance, ensuring it is not controlled by any single entity.
+
+## Mainnet and Testnet
+
+SettleMint supports, the **Fantom Mainnet** and the **Fantom Testnet**.
+
+The Mainnet is the primary public Fantom production blockchain where real-value transactions occur. Each transaction requires payment of a transaction fee, payable in the native coin FTM. The Testnet, on the other hand, is an instance of the blockchain used for testing and experimentation. The coins used in the Testnet have no real value, mitigating the risk of losing real funds.
+
+You can consider the Testnet as a prototype environment and the Mainnet as the official production blockchain, similar to the analogy of staging versus production servers.
+
+## Consensus mechanism
+
+The Fantom consensus algorithm is known as Lachesis, a unique asynchronous Byzantine Fault Tolerant (aBFT) protocol. Lachesis does not rely on leaders to propose blocks, allowing it to provide high throughput and fast finality. Transactions on the Fantom network are confirmed in about 1-2 seconds.
+
+Lachesis works as follows:
+
+	1.	**Asynchronous**: Transactions are processed asynchronously, meaning that validators do not need to wait for the previous transaction to be completed before starting a new one.
+	2.	**Byzantine Fault Tolerant**: The protocol can achieve consensus even if up to one-third of the nodes act maliciously.
+	3.	**Finality**: Transactions achieve finality within a few seconds, making them irreversible once confirmed.
+
+The Lachesis consensus algorithm is scalable, secure, and decentralized, providing a robust foundation for decentralized applications.
+
+More information can be found on the [official Fantom website](https://fantom.foundation/).

docs/blockchain-guides/11_Fantom/2_fantom-node-types.md

@@ -0,0 +1,5 @@
+# Node types
+
+All nodes running in SettleMint are configured to be **archive nodes**, meaning they all include all previous states of a given blockchain since its origin.
+
+[Learn here how to interact with your Fantom node.](3_fantom-connect-to-a-node.md)

docs/blockchain-guides/11_Fantom/3_fantom-connect-to-a-node.md

@@ -0,0 +1,72 @@
+# Connect to a node
+
+For a software application to interact with a blockchain (e.g. by sending transactions/data to the network, or even just by reading data), it must connect to a node. This section describes how to connect to your Fantom node.
+
+## Backend APIs
+
+Once a node has been deployed on an EVM (Ethereum Virtual Machine) compatible network, such as Fantom Mainnet, it can be accessed by different endpoints such as JSON-RPC, JSON-WS or GraphQL. You can connect to your already deployed node using these 3 most common endpoints.
+
+### JSON-RPC
+
+JSON-RPC, is a stateless, light-weight remote procedure call (RPC) protocol. Primarily, the specification defines several data structures and the rules around their processing. By default, the version of the JSON-RPC protocol needs to be 2.0, and you need to provide the node ID as well as a method and parameters.
+
+There are different kinds of methods that can be used: ADMIN methods, DEBUG methods, ETH methods etc.
+
+If you want to correctly connect to your node, you need to respect the right structure for the request, which is always the same:
+
+```json
+{
+"jsonrpc":"2.0"
+"Id": nodeId
+"method":"methodName"
+"params":{
+}
+}
+```
+
+If you want to connect to a node deployed on the SettleMint platform, go to the **Connect** tab on the **Node detail page** in the **Blockchain nodes** section of your application. Select JSON-RPC or any other endpoint and click **Try it out**. You will then be redirected to a new tab where you will be able to test different methods as well as the related Curl command line.
+
+### JSON-WS
+
+To make RPC requests over WebSockets, you can use wscat, which is by definition a Node.js based command-line tool. First you will need to connect to your node’s WebSocket server using wscat, as follows: `wscat -c ws://<JSON-RPC-ws-endpoint:port>`. All the credentials are provided in the **Connect** tab on the **Node detail page** in the **Blockchain nodes** section of your application. After you have established a connection, the terminal should display a '>' prompt. You will then be able to send individual requests as a JSON data package, as above, for instance:
+
+```json
+{
+"jsonrpc":"2.0"
+"Id": 1
+"method":"eth_blockNumber"
+"params":{
+}
+}
+```
+
+### GraphQL
+
+GraphQL is a query language and server-side runtime for API’s. It is designed to make APIs fast, flexible, and developer-friendly.
+We have a GraphQL interface that can be used with many different queries. These queries can be tested out in our GraphQL playground. You can also test out the different graphql queries with cURL, those request would look like this:
+
+```bash
+curl -X POST -H "Content-Type: application/json" -H “x-auth-token: <AUTH_TOKEN>” --data
+'{ "query": "{syncing{startingBlock currentBlock highestBlock}}"}' http://<DOMAIN>.settlemint.com/graphql
+```
+
+If you want to connect to a node deployed on the SettleMint platform, go to the **Connect** tab on the **Node detail page** in the **Blockchain nodes section** of your application. Select Graphql and click **Try it out**. This will bring you to the GraphQL playground where you can use all the different queries.
+
+## Javascript API
+
+If you do not want to use the above endpoints to connect to your node, it is possible to use plain Javascript. Several convenience libraries exist within the different ecosystem which makes connection much easier. With these libraries, developers around the world can write one-line methods to easily initiate requests (still under the hood) that interact with Ethereum or any other EVM compliant network. Note that some libraries might be available for Ethereum but not for the other networks.
+
+These libraries are very helpful and abstract away much of the complexity of interacting directly with your node. Most also provide useful and straightforward functions such as converting ETH to Gwei, so that you can spend less time dealing with decimal issues and more time on the functionality of your underlying application.
+
+One of the most commonly used libraries, Ethers, is extremely easy to use for signing transactions, sending tokens etc. For example:
+
+```typescript
+// If you don't specify a //url//, Ethers connects to the default
+// (i.e. ``http:/\/localhost:8545``)
+const provider = new ethers.providers.JsonRpcProvider();
+
+// The provider also allows signing transactions to
+// send ether and pay to change state within the blockchain.
+// For this, we need the account signer...
+const signer = provider.getSigner();
+```

docs/blockchain-guides/11_Fantom/4_fantom-network-stats.md

@@ -0,0 +1,27 @@
+# Network stats
+
+The dashboard gives you an overview of the following stats for the network:
+
+## Best block
+
+Shows the "heaviest" block in terms of cumulative difficulty. In other words, the latest block number of the longest valid chain.
+
+## Last block
+
+Shows the time, in seconds, since the last block was mined. This value is a good indicator of whether the network is still up and running. A value noticeably above the average time between blocks indicates that the network is no longer mining blocks.
+
+## Average block time
+
+Shows the average time, in seconds, it takes for the network to mine a new block.
+
+## Nodes
+
+Shows the number of nodes in this network.
+
+## Transactions
+
+Shows the number of transactions for the last 10 blocks.
+
+## Gas usage
+
+Shows the amount of gas spent for the last 10 blocks.

docs/blockchain-guides/11_Fantom/5_fantom-integration-tools.md

@@ -0,0 +1,70 @@
+# Smart contracts IDE
+
+The SettleMint IDE is the only tool you need to edit the smart contract set template you have selected, or **write** your own brand **new** smart contracts. The programming language used for your Fantom smart contracts is Solidity.
+
+## Using the IDE
+
+When you open the IDE, you land in an instance of Visual Studio Code similar to the image below.
+
+![ide](../../../static/img/blockchain-guide/IDE.png)
+
+On the left, in the **“Explorer”** panel, you can see all the folders and files related to the smart contract set.
+
+The smart contract files are located in the **“contracts”** folder. You can edit them, or use them as they are if the template fits all your needs.
+
+The **“deploy”** folder contains the scripts that enable the deployment of the smart contract set on the blockchain. You might have to edit these scripts if you add new arguments to the constructor of your smart contract.
+
+The **“test”** folder contains a script that lets you test the functionalities of your smart contracts. You can add new ones if you edit the template. Do not hesitate to go through the test cases as they provide valuable information on how to use your smart contracts.
+
+The **subgraph** folder holds all the files needed to index your smart contract using the Graph protocol.
+
+## Scripts
+
+Several scripts are defined in `package.json` to help you use the smart contract set:
+
+- **lint** to lint your smart contracts, i.e. find the stylistic errors.
+- **compile** to compile your smart contracts.
+- **test** to run the test script in the “test” folder.
+- **smartcontract:deploy** to deploy the smart contract set on the blockchain.
+- **smartcontract:deploy:reset** to deploy from scratch after a first deployment.
+- **graph:config** to create the middleware configuration file.
+- **graph:compile** to compile the middleware files.
+- **graph:codegen** to create the middleware schema.
+- **graph:build** to build the middleware.
+- **graph:deploy** to deploy the middleware.
+- **graph:all** to execute all the graph scripts in one command.
+
+:::warning Note
+
+To execute the scripts related to the Graph middleware, you need a middleware instance in your app.
+
+:::
+
+You can execute these scripts in the terminal integrated with the IDE by running `yarn name-of-script`.
+For example, to run the `smartcontract:deploy` task using the terminal, open a new terminal (ctrl + shift + \`) and run the command`yarn smartcontract:deploy`.
+
+## Private key
+
+To be able to deploy your smart contract set on the blockchain you need to have a private key enabled on your node to sign the transaction, and you need to fund this key with Ether to cover the cost for the transaction. You can create a private key and fund it in the **Private keys section** of your application. [More about private keys.](../../using-platform/17_private-keys.md)
+
+## Template library
+
+Every instance of the IDE contains a set of pre-built smart contract templates. These templates are easily customizable to match your specific use case. [Discover the smart contract set templates for Fantom.](../11_Fantom/Template-library/1_fantom-erc-20.md)
+
+## Generative AI plugin
+
+The integration of an OpenAI GPT plugin into the Smart Contract IDE of the SettleMint platform brings forth significant advantages for the fast development of new smart contracts. Generative AI technology empowers developers by providing them with automated code suggestions, smart contract templates, and code completion capabilities. This accelerates the development process by reducing manual effort and improving code efficiency.
+
+Additionally, the interactive debugging and explanation features offered by the GPT plugin greatly benefit developers of all skill levels. Beginners can leverage the plugin’s explanations to understand complex concepts, improve their coding skills, and gain insights into best practices. Experienced developers can utilize the debugging features to quickly identify and resolve issues, leading to more robust and error-free smart contracts.
+
+Overall, the integration of the OpenAI GPT plugin into the SettleMint platform’s Smart Contract IDE combines the power of generative AI and interactive debugging to enhance productivity, code quality, and learning opportunities for developers in the blockchain space.
+
+You can find this plugin in the sidebar (magic lamp icon), in context menu and the action panel. The first time you use the plugin you will get asked for an OpenAI API key. Depending on your OpenAI API access you can use the default GPT 3.5 model or the GPT 4 model which is slower, but more accurate. Check out the settings in the IDE to configure this and other settings (like using your own Azure GPT service)
+
+Here are some prompts to get you started:
+
+- Write a Solidity ERC20 token representing a bond, based on OpenZeppelin. Include a bond repayment and coupon payments.
+- Write a Solidity ERC721 token representing real estate, based on OpenZeppelin and allow fractional ownership of this NFT in the form of ERC20 tokens.
+- Write The Graph indexing code that indexes an ERC721 token on the Ethereum Mainnet.
+
+<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/-e4weLqbYjk" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>