On December 1st, 2028 wallet address ND7CPROTTHRTGYCQUYNIKPKKIWXGIEOHTPMRERQN2NIFD7USVKGTYGPJFE will release 660,000,000 MAGMA to the REDEAUX wallet.

Although we plan to retire MAGMA on ALGO in the first quarter of 2026 for the replacement of MAGMA's native blockchain, MoltenChain.

We will be offering a 1:1 trade from MAGMA on ALGO to MoltenChain where MAGMA is a native coin.

The MAGMA coin will be paired with USDC upon the mainnet launch, as we are working with Circle for the entire onboarding from debit/credit to the MoltenChain ecosystem.

The liquidity for MAGMA coin will be backed by USDC, all Algorand will be swapped to USDC-ALGO to USDC-MC and added to the liquidity pool.

Every purchase of MAGMA with USDC will be placed into a USDC/MAGMA liquidity pool. MAGMA holders will earn rewards for contributing to the liquidity pool.

Token creators will have a default liquidity pool setup for their tokens as ATOKEN/MAGMA LP. Where holders of their tokens can contribute to the LP and earn rewards for contributing to the LP.

Token creators will also have the option to add liquidity to any token on the network, they just need an equal value of both, which raises the TVL, and price of the token.

We are in the final stages of development before launching the public testnet, where we will stress and brutally attack to test it's durability and security.

As it stands, it can handle every attack method known to blockchain infrastructure and every attempt has been blocked, with the IP address resulting in being blacklisted.

We have been utilizing machine learning and we have created a sophisticated security model with an internal AI powered bot that monitors the network in real time.

As we continue to innovate what is stopping you from taking the leap into MAGMA?

We have succeeded in creating a deployable node developed in Bun, Hono.js, Drizzle, Drizzle ORM, WebSockets, IPFS, using Cloudflare Workers and D1.

The amount of work going into this has been a huge under taking. We are developing an entire ecosystem, powered by MAGMA.

There are a ton of different modules written in TypeScript. To host a node all you need is a Cloudflare account, or VPS, dedicated server; or self host in on a PC or Raspberry PI 4 or newer.

There will be a large amount of modules to extend the MoltenChain network, with a developer's API.

1. The MoltenChain Core - The main node for launching a MC core.

2. MC-Wallet-Module - The module for the wallet api.

3. MC-Auth-Module - The module for user auth api.

4. MC-MAGMA - A module for the 1st layer module for the native coin on MoltenChain, MAGMA.

5. MC-Sentry-Module - The Security module, uses a custom event listening node to protect the network from botnets, DDoS, and deployment of malicious MCSCs.

6. MC-Contract-Module - The API for deploying smart contracts to the MoltenChain Network.

7. MC-DPOS-Module - The API for a delagated proof-of-stake DAO, module.

8. MC-Messenger-Module - The messenger requires MC-Wallet-Module, sends and receives messages between users.

9. MC-Web-Module - True realtime Dapps writen in hono.JS, dynamically pushes content in HTML, HTMX, JavaScript and CSS.

10. MC-StoreAPI-Module - Build custom stores using MoltenChain.

With more under development.

Finally, the new MAGMA website is almost complete, but don't worry the old versions of the MAGMA website is hosted on Wayback Machine.

When a user wants to conduct a bridge swap from another network to MoltenChain a couple of things need to happen. Below is an example of how this will work.

Bob has 1 Bitcoin and wants to get 1 BTC worth in MAGMA, the Volcanic Wallet has a bridge swap built into it's features.

1. Bob will have to pay the additional fees associated with the bridge swap for the Bitcoin transaction.

2. Bob goes to the Volcanic Wallet, and creates a wallet.

3. Bob selects the SWAP tab, and selects SWAP FROM AN EXTERNAL NETWORK. Bob selects Bitcoin, then the amount he would like to swap.

4. The Volcanic Wallet calculates how much MAGMA Bob will receive, and the fees associated with the transaction.

5. Bob accepts, and gets prompted to send an exact amount of BTC to the Volcanic Wallet’s bridge address.

6. After 7 confirmations, the Volcanic Wallet will send Bob the amount of MAGMA to his wallet address as given in step 4.

7. Once the BTC transaction is completed, the Volcanic Wallet will automatically send the BTC to a MAGMA/BTC liquidity pool wallet address. This is where all incoming bridge swapped BTC will go, and where outgoing MAGMA to BTC bridge swaps will get the BTC from.

This will be the same for approximately 40 other cryptocurrencies.

Pre-funded Bridge Swap LP (LP between bridges)

BTC - $500,000 ETH - $500,000 USDC - $500,000 DOGE - $500,000 MANA - $500,000 EUROC - $500,000 CRO - $500,000 MATIC - $500,000 DOT - $500,000 MATIC - $500,000 ALGO - $500,000 ADA - $500,000 XLM - $500,000 ICP - $500,000 SOL - $500,000 AMP - $500,000 DAI - $500,000 SAND - $500,000 GRT - $500,000 BNB - $500,000 XRP - $500,000 USDT - $500,000 AVAX - $500,000 TRX - $500,000 LINK - $500,000 LTC - $500,000 COSMOS - $500,000 BCH - $500,000 NEAR - $500,000 OP - $500,000 NANO - $500,000 EOS - $500,000 ENJ - $500,000 IOTA - $500,000 XTZ - $500,000 EGLD - $500,000 ZIL - $500,000 COMP - $500,000 WAVES - $500,000 MOVR - $500,000

A total of $20,000,000 in liquidity for bridge swaps, this will not be launched at all at once. We will release a batch of new bridge swap origins and destinations every 3 months.

The primary LP for MAGMA will be setup with USDC from Circle, we are working with Circle to release a USDC token on MoltenChain, USDC-MC or mcUSDC.

In addition we are working on a solution for the future to allow fiat purchases of MAGMA.

MoltenChain is truly going to provide nextgen features and stability never seen before.

Our Volcanic Wallet is truly a nextgen wallet.

As the development continues we are constantly thinking outside of the box, bringing new ideas, features, and experiences in a single package.

Our security AI engine is undergoing a major code optimization and receiving a performance boost. We've trained it on a massive dataset of almost 16k exploits, double spending attempts, XSS, and payload attempts. This means that just like your virus detection and security software, MoltenChain scans transaction notes, messages, smart contracts, and dapps for potential issues and blocks them from ever being pushed through the network.

We also take node security very seriously. If a node reports a mis-matched code base, the network will lock it out, preventing it from validating, earning rewards, deploying smart contracts, or deploying dapps.

But that's not all - we're also focused on improving scalability. By increasing the speed of security checks, transactions and deployments will be even faster. Additionally, our code has been thoroughly optimized, resulting in quicker ping times, overall lower latency, and a 13% reduction in code with the re-write, making the package lighter than ever before.

Here at MoltenChain, we're driven to innovate and bring the most high-tech blockchain network to the world. By doing so, we're opening up new opportunities for independent musicians, writers, content creators, game devs, and artists. We are Redeaux Games and we can't wait to see what the future holds.

One of the key features of MNFT is the ability to create gig jobs and subscription-based NFTs. This means that creators can offer their services on a per-job basis or offer recurring NFTs that provide access to exclusive content or services. This opens up new opportunities for creators to monetize their skills and content in a unique and decentralized way.

Another powerful feature of MNFT is the ability to create reoccurring NFTs. This allows creators to offer ongoing access to their content or services, creating a sustainable revenue stream for themselves. This is especially useful for creators who offer subscription-based content or services, as it eliminates the need for centralized payment processors and allows them to directly receive payments from their subscribers.

MNFT also supports the creation of different types of NFTs, including wrapped NFTs, which represent assets on other blockchain networks, and hybrid NFTs, which combine multiple NFT standards into a single token. This provides even greater flexibility for developers and creators to build unique and innovative applications on the blockchain.

The MoltenChain platform provides a range of tools and resources to support the development and management of MNFTs. This includes the ability to create and deploy smart contracts, as well as access to MoltenChain's robust API for seamless integration with external systems and applications.

Overall, MNFT is a powerful and versatile standard that opens up new possibilities for creators and developers in the world of decentralized applications. With features such as gig jobs, subscription-based NFTs, and reoccurring NFTs, MNFT provides a unique way for creators to monetize their skills and content while providing a sustainable revenue stream. The possibilities for MNFT are endless, and we can't wait to see what the future holds for this exciting standard.

Hot loadable modules offer a number of benefits for developers. First, they enable rapid development and deployment of new features, allowing dapps to keep up with changing market demands and user needs. Second, they make it easy to experiment with new features and ideas, without the risk of disrupting the entire network.

MoltenChain's hot loadable modules also provide a high level of flexibility and customization. Developers can choose to use pre-built modules, or they can build their own custom modules to meet their specific requirements. This allows for a highly modular and extensible development approach that can adapt to a wide range of use cases.

Overall, MoltenChain's hot loadable modules are a powerful tool for blockchain developers looking to build scalable and flexible dapps. With their ability to dynamically load and unload modules, developers can experiment with new features, add new functionality to their dapps, and keep up with changing market demands.

In addition to its core blockchain features, MoltenChain offers a range of modules that enable developers to build a wide range of dapps. These modules include a messaging module that uses Socket.io for real-time communication, a liquidity pool module that enables the creation of liquidity pools for different tokens, and a voting module that allows users to participate in decentralized voting.

MoltenChain also supports the development of smart contracts using the Lua programming language. Smart contracts can be used for a variety of use cases, including decentralized exchanges, prediction markets, supply chain management, identity verification, and more.

One of the key features of MoltenChain is its bridge swapping functionality, which enables tokens to be exchanged between different blockchain networks. This makes it easy for developers and businesses to integrate with other blockchain networks and build interoperable decentralized applications.

MoltenChain also supports the creation of fungible tokens, wrapped tokens, and non-fungible tokens (NFTs). Fungible tokens are digital assets that are interchangeable and have the same value, while NFTs are unique digital assets that cannot be replicated. Wrapped tokens are tokens that represent assets on other blockchain networks and can be exchanged for the underlying asset.

To ensure accurate pricing for tokens, MoltenChain also provides an oracle module that sources price data from external sources and makes it available on the network. This enables developers to build decentralized applications that require real-time pricing data.

Scalability and performance are key priorities for MoltenChain, and the platform has been designed to support high transaction volumes and low latency. To achieve this, MoltenChain uses a high-performance tech stack that includes Node.js, TypeScript, and Lua.

MoltenChain also features a robust API that provides easy integration with external services and applications. This enables developers to build dapps that can communicate with external systems and provide a seamless user experience.

Another feature of MoltenChain is its MNFT (Molten Non-Fungible Token) standard, which enables the creation of unique digital assets that can be used in a wide range of applications. MNFTs can be used for digital art, gaming, collectibles, and more.

Finally, MoltenChain provides a user-friendly wallet application called Volcanic Wallet, which makes it easy for users to store and manage their digital assets. The wallet supports a range of cryptocurrencies and tokens, and includes features such as transaction history, balance tracking, and more.

In summary, MoltenChain is a powerful and versatile blockchain platform that provides developers and businesses with the tools they need to build innovative and scalable decentralized applications. With its fast and secure consensus mechanism, support for smart contracts and multiple types of tokens, bridge swapping functionality, oracle module, and MNFT standard, MoltenChain is poised to make a significant impact on the blockchain industry. The user-friendly Volcanic Wallet and robust API also make it easy for developers and users to engage with the platform and build exciting new applications.

MoltenChain's Features

We have written in many functions into the core base of MoltenChain's source code.

Here is a list of MoltenChain's built in features.

1. 5 second transaction time.

2. Quick fetch for bringing new nodes online quickly.

3. Mint and deployment of FTs, and NFTs.

4. Wallet functionality with atomic swapping.

5. Local and remote JSON as a DB function.

6. A smart contract mechanism for Lua scripting language.

7. Full compatibility with IPFS, webtorrent and H5P.

8. Light weight source code with quick deployment for easier to manage nodes and quick start for devs.

9. A built in Liquidity function.

10. Built in locking function for liquidity and tokens.

11. Custom address system with namespace style wallet addresses, example: lolcatz.magma or yourname.magma

12. Simple to use and easy to understand dev api.

When does MoltenChain launch?

Although there is not a launch date set in stone, right now the current projections are MoltenChain testnet will launch around July 2023.

With a potential for a mainnet coin pre-sale launch around October 2023.

How secure will MoltenChain be overall?

TypeScript uses the TypeScript compiler (tsc), which checks for errors and compiles TypeScript into JavaScript. Certain compiler options increase security, such as strict and noEmitOnError.

The former increases security by turning on a series of flags to force TypeScript to run in a stricter mode. For example, it turns on things such as noImplicitAny, strictNullChecks, and noImplicitThis, all of which protect your application from including unsafe constructs.

In addition, the option noEmitOnError prevents the tsc from creating the corresponding JavaScript file if there is an error within the code, increasing security by preventing errors from being compiled into JavaScript code.

While more code is written, you are generating more code to increase security. The extra code defines types and adds type checks and validation functions. Types define what input is allowed into an object; not having types can cause errors and potential security weaknesses. In TypeScript, the types are strings, numbers, and interfaces, which can help define the syntax of future type checks and input validation.

Writing extra code upfront to define types and ensure type safety can help save time by preventing developers from having to fix type errors later.

Fixing type errors in languages without static, strict types is difficult - you have to figure out where in the code the error is generating from, how to fix it, and determine if any other errors resulted from the fix, all without the help of the IDE or the language itself. While in a strict static typed language, it will prevent these issues entirely and report any additional errors during compilation.

Dynamic Typing is a security problem, because it only checks types at runtime. Therefore, any security issues are caught while the application is running and not while it is under development.

Static typing checks types at compile-time, which prevents type issues before they become vulnerabilities.

When you are trying to remediate the source of an error or weakness, it takes longer to edit code in dynamic typing than in static typing.

This is due to the expressive errors and compile-time type checks native to static typing. More expressive errors give more information about where the code's errors lie, such as the file and line number.

Checking types at compile time means that errors are found closer to the source, making it easier to return and fix than if the error was found during runtime. 

TypeScript Security Win: TypeScript provides static typing, which checks types at compile-time, preventing issues before they become vulnerabilities, and giving more expressive errors to aid in the identification and resolution of errors.

TypeScript Security Win: TypeScript uses strict typing, preventing accidental typing mistakes that lead to common weaknesses within an application.

These new games use the new version of SULFUR, the MAGMA Discord server's virtual cash!

Truth Or Dare 🔪 is a new CMDR hosted game taking place after Texas Hold Em Poker on Thurdays!

It will use the SULFUR v2 that ships with MAGMA BOT.

This version of SULFUR will only be able to be won and earned currently. We are not swapping this version with MAGMA.

There will be a full update on this in the near future.

On MoltenChain as well as minting tokens, the token creators can also deploy a smart contract to set up a side-chain for the token. With side-chains token creators can provide an independent ledger named after the token id.

Example: Bob creates Bobcoin with the ticker as BOBS, when Bob deploys the smart contract for the side-chain it will be named BOBS Chain. All swaps, exchanges, token lock-ups, LP buys or sells will be listed in the BOBS Chain ledger.

To learn more head over to MoltenCha.in.

With the private messages module, smart contracts can be deployed to make these private messages self destruct.

1. Message will self destruct if not opened within a specified amount of time.

2. Message will self destruct after message has been opened.

3. Message will self destruct after a payment is received.

4. Message will self destruct after a payment is sent.

We are writing a section into the Volcanic Wallet UI. The smart contracts are written and currently being tested in a private testnet setting.

To check out the smart contracts please go to our Github.

Initial LP Options

When we launch MoltenChain and MAGMA to mainnet we will create liquidity pools with the following pairs:

1. USD/USDC to MAGMA | We will keep USD in a US bank account with the matched amount in USDC. On MoltenChain we will deploy a smart contract, and oracle to power the bridge and liquidity pool.

2. ALGO to MAGMA | We will keep ALGO in a wallet, matched to the amount of MAGMA to create a liquidity pool with Algorand and MAGMA, on MoltenChain we will deploy a smart contract, and oracle to power the bridge and liquidity pool.

3. ADA to MAGMA | We will keep ADA in a wallet, matched to the amount of MAGMA to create a liquidity pool with Cardano and MAGMA, on MoltenChain we will deploy a smart contract, and oracle to power the bridge and liquidity pool.

4. BTC to MAGMA | We will keep BTC in a wallet, matched to the amount of MAGMA to create a liquidity pool with Bitcoin and MAGMA, on MoltenChain we will deploy a smart contract, and oracle to power the bridge and liquidity pool.

5. ETH to MAGMA | We will keep ETH in a wallet, matched to the amount of MAGMA to create a liquidity pool with Ethereum and MAGMA, on MoltenChain we will deploy a smart contract, and oracle to power the bridge and liquidity pool.

As time goes on we will expand the pairs offered including MAGMA Stables a tethered token powered by Oracles and a swapping bridge. MAGMA Stables will be available on the following networks:

1. MAGMA-ALGO | A MAGMA stable token on the Algorand network.

2. MAGMA-ETH | A MAGMA stable token on the Ethereum network.

3. MAGMA-ADA | A MAGMA stable token on the Cardano network.

4. MAGMA-LINK | A MAGMA stable token on the ChainLink network.

5. MAGMA-DC | A MAGMA stable token on the DogeChain network.

6. MAGMA-ICP | A MAGMA stable token on Internet Computer network.

7. MAGMA-IOTA | A MAGMA stable token on the IOTA network.

8. MAGMA-ATOM | A MAGMA stable token on the Cosmos network.

9. MAGMA-BNB | A MAGMA stable token on the Binance network.

10. MAGMA-NEAR | A MAGMA stable token on the NEAR network.

11. MAGMA-ZIL | A MAGMA stable token on the Zilliqa network.

12. MAGMA-MATIC | A MAGMA stable token on the Polygon network.

13. MAGMA-TRX | A MAGMA stable token on the Tron network.

14. MAGMA-DOT | A MAGMA stable token on the Polkadot network.

15. MAGMA-XLM | A MAGMA stable token on the Stellar network.

16. MAGMA-PLS | A MAGMA stable token on the PulseChain network.

17. MAGMA-HECO | A MAGMA stable token on the HECO network.

18. MAGMA-VLX | A MAGMA stable token on the Velas network.

19. MAGMA-FTM | A MAGMA stable token on the Fantom network.

20. MAGMA-SOL | A MAGMA stable token on the Solana network.

Since the native MAGMA on MoltenChain will have so many stable tokens we will need to make these tokens interchangeable, to do that we will need a liquidity pool for each pair. This is why the native MAGMA will have a total supply of 16,317,000,000 MAGMA.

The amount of MAGMA for each pair is 777,000,000 MAGMA and since there is a total of 21 networks, 777000000x21=16317000000.

The initial value of MAGMA on MoltenChain will be 0.0000007000, which is valued at $543.90 per network. With the addition of Bitcoin, Litecoin and Dogecoin.

Each MAGMA stable token will require $543.90 in liquidity with their network's parent coin, for example:

MAGMA-ALGO will require liquidity on the Algorand side with $543.90 of ALGO matched with MAGMA-ALGO, but on the MoltenChain side, we will require liquidity of 777,000,000 MAGMA to MAGMA-ALGO.

By the time we are finished, we should have a total of 50 liquidity pools with $543.90 of liquidity for each one, totaling $27,195 at $0.0000007000 per MAGMA.

We are in talks with Circle in joining them as a possible partner, in the future to handle our FIAT to MAGMA process. Circle transaction fees will be passed on to the buyer, so we can ensure the presence of liquidity.

What is TypeScript?

TypeScript adds additional syntax to JavaScript to support a tighter integration with your editor. Catch errors early in your editor.

TypeScript code converts to JavaScript, which runs anywhere JavaScript runs: In a browser, on Node.js or Deno and in your apps.

TypeScript understands JavaScript and uses type inference to give you great tooling without additional code.

Crypto in TypeScript

The following Node modules were used:

• nodemon for automatic reloading of project on every save (npm i nodemon –save-dev)

• jest for unit testing (npm i jest –save-dev)

• @types-jest (npm i @types/jest) for importing Jest symbols into TypeScript unit tests

• typescript for writing code in TypeScript (npm i -g typescript)

• tslint (npm i tslint -g)

• crypto-js (cryptographic package for generating SHA-256 hashes) (npm i crypto-js –save)

• @types/crypto-js (npm i @types/crypto-js –save) for importing crypto-js symbols into TypeScript

• express as a HTTP web server (npm i express –save)

• @types/express for importing express symbols into TypeScript (npm i @types/express –save-dev)

• body-parser as middleware for parsing HTTP requests and receiving POST requests in JSON format (npm i body-parser –save)

• ws, a Node.js web socket library (npm i ws –save)

• @types/ws – type definitions for ws (npm i @types/ws –save)

• elliptic – for using elliptic curve cryptography to generate public-private keypairs (npm i elliptic –save)

• uuid – for generating unique transaction ID’s (npm i uuid –save)

• @types/uuid – type definitions for uuid (npm i @types/uuid –save)

• +FT & NFT deployement baked directly into MoltenChain

• VolcanicWallet functions baked directly into MoltenChain

• DirectStorage API baked directly into MoltenChain

• MAGMAPay API baked directly into MoltenChain

TypeScript Configuration and Issues

TypeScript compiler options were set to be more strict to make the code more type safe. Specifically, the “noImplicitAny” was set to “true” to make the compiler force the use of explicit types throughout the code.

tsconfig.json used for this project.

{ "compilerOptions": { "strictNullChecks": true, "noImplicitAny": true, "moduleResolution": "node", "target": "es5", "lib": [ "es2015", "dom" ], "sourceMap": true }, "include": [ "src/**/*", "test/**/*", ], }

The compiler target in tsconfig.json was set to “es5”. When I tried to set it to “es6” I had many problems running Jest tests because Node does not support es6 imports and I was getting the runtime error: “SyntaxError: Unexpected token import” when importing a module like this:

import { Block } from "../../src/blockchain/block"

// So then I tried setting the compile target in tsconfig.json to “es5” but that would result in a compilation error in one of the ws (web sockets) type definition file (web sockets):

node_modules/@types/ws/index.d.ts:181:18 - error TS2304: Cannot find name 'Set'

// So I was stuck and tried to find a solution. I looked at using Babel to transpile from ES6 to ES5 as well as using

node --experimental-modules file.mjs

// as outlined in Stack Overflow question: Node.js – SyntaxError: Unexpected token import .

// I finally found a more simple solution on this Stack Overflow answer that talks about using the “lib” compiler option in tsconfig.json:

"lib": ["es2015", "dom"]

// which referenced the Angular TypeScript documentation that stated:

TypeScript includes a special declaration file called lib.d.ts. This file contains the ambient declarations for various common JavaScript constructs present in JavaScript runtimes and the DOM.

Based on the --target, TypeScript adds additional ambient declarations like Promise if the target is es6.

Since the QuickStart is targeting es5, you can override the list of declaration files to be included:

content_copy
"lib": ["es2015", "dom"]
Thanks to that, you have all the es6 typings even when targeting es5.

Unit Testing with Jest

This blockchain was thoroughly unit tested using the Jest testing framework. All Jest unit tests are in the Github test folder and are appended with a “.test” to correspond with the file they are testing. For example, transaction.test.ts contains the unit tests for transaction.ts.

Jest needs to be configured to run in Node mode instead of its default “jsdom” or browser mode. The jest section in package.json, is:

"jest": {
"transform": {},
"testRegex": "/test/.*\.test\.(js)$",
"testEnvironment": "node"
}

Blockchain – Trustless System

A blockchain is a public and immutable shared ledger that stores all transactions for an application, such as a cryptocurrency like Bitcoin and Ethereum. For a cryptocurrency application, the ledger stores all transactions such as who transferred funds to who, similar to a bank ledger. Each set of transactions is represented as a block on the blockchain. A block can store multiple transactions, as shown in the demo video.

Once a transaction has been committed (mined) to the blockchain (ledger), it can’t be edited or removed. Also, all nodes on the blockchain network keep a replicated copy of the blockchain so there is no central place where the block chain is stored. When a new block is added to the blockchain, all nodes in the blockchain network are updated to have the newest version of the blockchain.

Every block in the chain is linked to the previous block by storing the hash value of the previous block, which creates a chain of blocks.

Instead of a central trusted authority like a bank, the blockchain network itself acts as the trusted authority because of its built in trust and security features. This eliminates the need for middle men such as banks and doesn’t have a single point of failure. An attacker would have to take over a large segment of a blockchain network in order to compromise it whereas a bank robber only needs to rob a single bank to steal a lot of money.

Block Class

The fundamental object of the blockchain is the block, which represents an individual link in the blockchain. The blockchain stores the following properties:

• current hash (based on the timestamp, hash of previous block and transactions)

• hash of the previous block

• timestamp

• data to store (cryptocurrency transactions but can store generic data, as well)

• nonce value (for mining new blocks)

• difficulty value (for mining new blocks)

The code for the Block class is in src/blockchain/block.ts. This snippet shows the above properties:

export default class Block {

timestamp: number;

lastHash: string;

hash: string;

//for cryptocurrency - transactions are the data in each block //but the blockchain can hold any data data: any; nonce: number;

difficulty: number;

}

Genesis Block

The Genesis Block is the very first block in a blockchain – a way to start a blockchain. Since there’s no preceding block, the genesis block uses hard coded dummy values for its previous hash value. This way, when the second block gets added to the blockchain, it will set the value of its previous hash to the hash of the genesis block. Since the genesis block is hard coded, we make it a static method of the Block class, so it’s accessible without instantiating a Block object.

The code for the genesis block is in src/blockchain/block.ts:

/** * First block of the blockchain. */ static getGenesisBlock(): Block { let genesisTx: Transaction = new Transaction(); genesisTx.id = "genesis"; genesisTx.txInput = new TransactionInput(0, "-----"); return new Block(0, '-----', 'f1r5t-ha4h', genesisTx, 0, config.DIFFICULTY); }

Blockchain Class

The Blockchain class is responsible for

• storing the list of blocks on the blockchain

• adding new blocks to the chain

• validating new blockschains

• replacing current blockchain with a new one (when synchronizing with other nodes)

The code for the blockchain class is in src/blockchain/index.ts. The following code snippet shows the storage of an array of blocks within the Blockchain class, which illustrates that when a new blockchain is created, it comes pre-loaded with a single block – the genesis block:

export default class Blockchain { chain: Block []; constructor() { this.chain = [Block.getGenesisBlock()]; } }

Blockchain Replication

Every node on the network needs to have the same copy of the blockchain. So what happens when a new block gets mined on one node? Now the system has to replicate the new block to all the other nodes on the network so every node is in sync and has the same copy of the blockchain.

Since the blockchain needs to be replicated among all nodes in the network, the question arises – what happens if two nodes mine a block at the same time? This is when there’s a fork in the blockchain and the system needs to reconcile the fork and merge all the new blocks.

When a fork occurs, some nodes will get replicated from node A and some will get replicated from node B which will create the following scenario:

We will use the rule that the longest chain will be accepted as the main chain. If there is a conflict between multiple nodes mining blocks at the same time, eventually, one chain will be longer and that will be accepted as the master blockchain. The other blocks that were mined on the shorter chain will be incorporated into the main blockchain.

Web Application

The web application expose a series of JSON endpoints that will allow each node on the network to interact with the blockchain with its own HTTP server:

• GET /blocks – view node’s copy of the full blockchain

• GET /balance – view node’s wallet balance

• GET /public-key – view node’s public key (to know the wallet address to transfer cryptocurency to)

• GET /transactions – view node’s copy of the transaction pool (transactions that haven’t been mined)

• POST /mine – to add a generic new block to the chain (for adding non cryptocurrency blocks to the blockchain)

• POST /mine-transactions – to add cryptocurrency transactions to the blockchain

• POST /transact – add cryptocurrency transaction to the transaction pool

The code for the web application is in src/app/index.ts:

Peer-to-Peer Server

Each node on the blockchain network needs the ability to communicate with other nodes (peers) on the network in order to:

• get an updated blockchain from its peers

• for broadcasting to other nodes when it has an updated version of the blockchain

Each peer-to-peer server uses web sockets instead of HTTP to communicate with each node.

Blockchain synchronization between nodes is done by sending a synchronization message to other nodes as soon as new block is mined on any node. However, before a node replaces its blockchain from an update it received from one of its peers, it needs to check that the updated chain is longer than its current chain and that the new blockchain is valid (by validating its hashes). For new nodes that just join the network, they get an updated version of the blockchain from one of its peers.

The peer-to-peer server is also responsible for synchronizing and clearing the transaction pool between nodes.

The code for the peer-to-peer server is in src/app/p2p-server.ts, which contains the code for blockchain synchronization between nodes:

/**
 * Convenience method for sending blockchain on a socket.
 * Specifies that message contains blockchain by setting "type" parameter.
 * @param webSocket The WebScoket to send the blockchain on.
 */
sendChain(webSocket: WebSocket): void {
  webSocket.send(JSON.stringify({
    type:MESSAGE_TYPES.chain,
    chain: this.blockchain.chain
  }));
}

The peer-to-peer server is also responsible for processing incoming messages from other nodes and determining what to do, based on the message type. There are three message command types:

• replace the current blockchain with a new blockchain

• update or add a new transaction in the transaction pool

• clear the transaction pool

Code snippet for processing incoming messages:

/**
 * Process incoming message, based on the message type.
 * @param socket Socket of incoming message.
 */
messageHandler(socket: WebSocket): void {
  socket.on("message", message => {
    const messageData = JSON.parse(message.toString());

    switch(messageData.type) {
      case MESSAGE_TYPES.chain:
        this.blockchain.replaceChain(messageData.chain);
        break;
      case MESSAGE_TYPES.transaction:
        this.tp.updateOrAddTransaction(messageData.transaction);
        break;
      case MESSAGE_TYPES.clear_transactions:
        this.tp.clear();
        break;
      default:
        throw new Error("Undefined message type: " + messageData.type);
    }
  });
}

Cryptocurrency App

On top of our blockchain, we have a cryptocurrency app that leverages the blockchain to allow transferring digital currency between individuals. Our cryptocurrency app consists of:

• Wallet object for each user

• Public-private key pair for digital signatures and verifying signatures from other people

• Transaction objects to represent the currency exchange between parties

Cryptocurrency Wallet

Our cryptocurrency app uses a wallet to store a user’s balance and the public-private key pair. The private key is used to generate digital signatures and the public key is used to verify signatures from other people. The public address of the wallet is just the public key. The key pair is generated with secp256k1 elliptical algorithm, the same algorithm used by Bitcoin.

The wallet class is implemented in src/wallet/index.ts. Here is a snippet that shows the wallet properties and constructor. Note that each wallet starts with a pre-set balance.

export default class Wallet {
    balance: number;
    keypair: any;
    publicKey: any;
    static bcWallet: Wallet;

    //for balance re-calculation - need to know from where to start recalculating
    lastBlockTimestamp: number;

    //when last did balance recalculation, this was the last block
    lastBlockBalanceCalc: number;

    constructor() {
        this.balance = config.INITIAL_BALANCE;
        this.keypair = ChainUtil.genKeyPair();
        this.publicKey = this.keypair.getPublic().encode("hex");
        this.lastBlockTimestamp = 0;
        this.lastBlockBalanceCalc = 0;
    }
}

Blockchain Wallet

The blockchain wallet is implemented in the Wallet class as a Singleton so the same wallet instance can be reused. The blockchain wallet code is in src/wallet/index.ts:

/**
 * Uses Singleton pattern to retrieve the special Blockchain Wallet.
 * Creates it only one time.
 */
static getBlockchainWallet():Wallet {
  if(!Wallet.bcWallet) {
    Wallet.bcWallet = new this();
    Wallet.bcWallet.publicKey = config.BLOCKCHAIN_WALLET_ADDRESS;
  }
  return Wallet.bcWallet;
}

Cryptocurrency Transactions

Each block in the blockchain will store one or more cryptocurrency transactions. Since the blockchain is a permanent record of all transactions, each user can see a complete history of their transactions on the blockchain. Each transaction object consists of:

• a unique ID to identify the transaction object (to make transactions easier to find in large collections)

• a single Transaction Input object

• an array of Transaction Output objects

Code for the Transaction class is in src/wallet/transaction.ts. Here is a snippet of the properties of the Transaction class:

export default class Transaction {
    id: string;
    txInput: TransactionInput;
    txOutputs: TransactionOutput[];

    constructor() {
        this.id = ChainUtil.genID();
        this.txOutputs = [];
    }
}

Each Transaction Input object contains:

• the sender’s address (which is their public key)

• sender’s starting balance before the transaction

• timestamp

• sender’s signature of the transaction

Code for the Transaction Input class is in src/wallet/transaction-input.ts:

export default class TransactionInput {
    amount: number;
    address: string;
    timestamp: number;
    signature: string;
    constructor(amount: number, address: string) {
        this.amount = amount;
        this.address = address;
    }
}

Each Transaction Output object contains:

• recipient of transaction (i.e. the other wallet)

• amount of currency transferred to recipient

Code for the Transaction Output class is in src/wallet/transaction-output.ts:

export default class TransactionOutput {
    amount: number;
    address: string;
}

Since MoltenChain is a Proof-Of-Stake Blockchain our code works a little differnet...

MAGMA NATIVE ON MOLTENCHAIN in TypeScript

MoltenChain and MAGMA Coin initialization script

import { Block, Blockchain, Transaction } from "./blockchain";

class MAGMA extends Token { constructor(name: string, symbol: string, totalSupply: number) { super(name, symbol, totalSupply); }

static createNewToken(name: string, symbol: string, totalSupply: number) { return new MAGMA(name, symbol, totalSupply); } }

class MoltenChain extends Blockchain { constructor() { super(); }

static createNewBlockchain() { return new MoltenChain(); }

static createNewTransaction(sender: string, receiver: string, amount: number) { return new Transaction(sender, receiver, amount); }

static createNewBlock(prevHash: string, transactions: Transaction[]) { return new Block(prevHash, transactions); } }

const proofOfStake = (blockchain: MoltenChain, token: MAGMA) => { const currentBlock = blockchain.getLatestBlock(); const validators = token.getTopHolders();

let selectedValidator: string; let maxStake = 0;

validators.forEach(validator => { const stake = token.balanceOf(validator); if (stake > maxStake) { selectedValidator = validator; maxStake = stake; } });

if (selectedValidator) { currentBlock.validator = selectedValidator; } };

const createNewMAGMAToken = (name: string, symbol: string, totalSupply: number) => { const magmaToken = MAGMA.createNewToken(name, symbol, totalSupply); console.log(Successfully created new MAGMA token: ${magmaToken.name} (${magmaToken.symbol}) with total supply of ${magmaToken.totalSupply}); return magmaToken; };

const createNewMoltenChainBlockchain = () => { const moltenChain = MoltenChain.createNewBlockchain(); console.log(Successfully created new MoltenChain blockchain.); return moltenChain; };

const createNewTransaction = (sender: string, receiver: string, amount: number, moltenChain: MoltenChain, magmaToken: MAGMA) => { magmaToken.transfer(sender, receiver, amount); const transaction = MoltenChain.createNewTransaction(sender, receiver, amount); moltenChain.addTransaction(transaction); console.log(Successfully added new transaction to MoltenChain blockchain: ${JSON.stringify(transaction)}); return transaction; };

const createNewBlock = (moltenChain: MoltenChain, magmaToken: MAGMA) => { const prevHash = moltenChain.getLatestBlock().hash; const transactions = moltenChain.pendingTransactions; proofOfStake(moltenChain, magmaToken); const block = MoltenChain.createNewBlock(prevHash, transactions); moltenChain.addBlock(block); console.log(Successfully added new block to MoltenChain blockchain: ${JSON.stringify(block)}); return

WALLET IN TYPESCRIPT

import { MoltenChain, MAGMA } from "./moltenChain";

class Wallet { private balance: number; private moltenChain: MoltenChain; private address: string;

constructor(address: string, moltenChain: MoltenChain) { this.balance = 0; this.moltenChain = moltenChain; this.address = address; }

public async createNewToken(proofOfStake: number): Promise { if (this.balance < proofOfStake) { throw new Error("Insufficient funds to create new token"); } this.balance -= proofOfStake; return this.moltenChain.createNewToken(this.address, proofOfStake); }

public async transferToken(token: MAGMA, recipient: string, amount: number): Promise { if (this.balance < amount) { throw new Error("Insufficient funds to transfer token"); } this.balance -= amount; return this.moltenChain.transferToken(token, this.address, recipient, amount); }

public async getBalance(): Promise { return this.moltenChain.getBalance(this.address); } }

MOLTENCHAIN NFT DEPLOYMENT

define the MAGMA cryptocurrency and MoltenChain blockchain class MAGMA { constructor() { this.balance = 0; } }

class MoltenChain { constructor() { this.chain = []; this.currentBlock = { nonce: 0, data: [], previousHash: '' }; this.difficulty = 3; this.pendingTransactions = []; }

// proof of stake protocol to create a non fungible token createNonFungibleToken(data: any, stake: MAGMA) { // check if stake is sufficient if (stake.balance < this.difficulty) { console.log('Insufficient stake'); return; }

// create a new block with the non fungible token data let newBlock = { nonce: this.currentBlock.nonce + 1, data: data, previousHash: this.currentBlock.previousHash };

// add the new block to the chain and update the current block this.chain.push(newBlock); this.currentBlock = newBlock;

// decrease the stake balance and add the non fungible token to the pending transactions stake.balance -= this.difficulty; this.pendingTransactions.push({type: 'nonFungibleToken', data: data}); } }

MOLTENCHAIN MINT FUNGIBLE TOKEN

import { Block, Blockchain, Transaction, FungibleToken, ProofOfStake } from 'moltenchain';class MAGMA implements FungibleToken { private name: string; private symbol: string; private totalSupply: number; private transactions: Transaction[];constructor(name: string, symbol: string, totalSupply: number) { this.name = name; this.symbol = symbol; this.totalSupply = totalSupply; this.transactions = []; }public getName(): string { return this.name; }public getSymbol(): string { return this.symbol; }public getTotalSupply(): number { return this.totalSupply; }public transfer(from: string, to: string, amount: number): boolean { // validate transaction if (amount <= 0 || !this.validateTransaction(from, to, amount)) { return false; }// create new transaction const transaction = new Transaction(from, to, amount); this.transactions.push(transaction); return true; }public balanceOf(address: string): number { let balance = 0; for (const transaction of this.transactions) { if (transaction.from === address) { balance -= transaction.amount; } if (transaction.to === address) { balance += transaction.amount; } } return balance; }private validateTransaction(from: string, to: string, amount: number): boolean { // check if sender has sufficient balance if (this.balanceOf(from) < amount) { return false; } return true; } }class MoltenChain extends Blockchain { private proofOfStake: ProofOfStake; private magma: MAGMA;constructor(proofOfStake: ProofOfStake, magma: MAGMA) { super(); this.proofOfStake = proofOfStake; this.magma = magma; }public createBlock(data: any): Block { // validate block with proof of stake if (!this.proofOfStake.validateBlock(data)) { throw new Error('Invalid block'); }// create new block with data and previous hash const block = new Block(data, this.getLatestBlock().hash); this.addBlock(block); return block; }public getFungibleToken(): MAGMA { return this.magma; } }const proofOfStake = new ProofOfStake(); const magma = new MAGMA('MAGMA', 'MAG', 1000000); const moltenChain = new MoltenChain(proofOfStake, magma);console.log(moltenChain.getFungibleToken().transfer('wallet1', 'wallet2', 500)); console.log(moltenChain.getFungibleToken().balanceOf('wallet1')); console.log(moltenChain.getFungibleToken().balanceOf('wallet2'));moltenChain.createBlock({ data:

GRAB MNFT METADATA FROM MOLTENCHAIN

import { Block, Transaction, NonFungibleToken } from 'moltenchain';

class MAGMA implements NonFungibleToken { // Non-fungible token metadata name: string; symbol: string; totalSupply: number; owner: string; metadata: any;

constructor(name: string, symbol: string, totalSupply: number, owner: string, metadata: any) { this.name = name; this.symbol = symbol; this.totalSupply = totalSupply; this.owner = owner; this.metadata = metadata; } }

class MoltenChain { // Blockchain properties chain: Block[]; currentBlock: Block; difficulty: number;

// Proof of stake properties validators: string[]; stake: number;

constructor(difficulty: number, validators: string[], stake: number) { this.chain = [this.createGenesisBlock()]; this.currentBlock = this.chain[0]; this.difficulty = difficulty; this.validators = validators; this.stake = stake; }

// Creates the first block in the blockchain (genesis block) createGenesisBlock(): Block { return new Block(Date.now(), [], '0'); }

// Returns the latest block in the blockchain getLatestBlock(): Block { return this.chain[this.chain.length - 1]; }

// Adds a new block to the blockchain addBlock(newBlock: Block): void { newBlock.previousHash = this.getLatestBlock().hash; newBlock.mineBlock(this.difficulty); this.chain.push(newBlock); }

// Validates the blockchain isChainValid(): boolean { for (let i = 1; i < this.chain.length; i++) { const currentBlock = this.chain[i]; const previousBlock = this.chain[i - 1];

// Check if block has been tampered with if (currentBlock.hash !== currentBlock.calculateHash()) { return false; }

// Check if previous block hash points to the correct block if (currentBlock.previousHash !== previousBlock.hash) { return false; } } return true; }

// Adds a new transaction to the blockchain addTransaction(transaction: Transaction): number { if (!transaction.fromAddress || !transaction.toAddress) { throw new Error('Transaction must include from and to addresses'); }

// Check if validator has sufficient stake if (this.validators.indexOf(transaction.fromAddress) === -1 || this.stake < transaction.amount) { throw new Error('Validator does not have sufficient stake'); }

// Add transaction to current block this.currentBlock.transactions.push(transaction);

// Check if block is full and create a new one if it is if (this.currentBlock.transactions.length >= this.difficulty) { this.addBlock(new Block(Date.now(), [], this

This a rough write-up, we currently testing it and improving the code.

Tightening it up, even more, the smart contracts on MoltenChain are written in Lua.

import { Blockchain, Block, FungibleToken, NonFungibleToken, SmartContract, ProofOfStake } from 'moltenchain';

class MAGMA extends Blockchain {
constructor() {
super();
this.name = 'MAGMA';
this.consensus = new ProofOfStake();
}

createFungibleToken(name: string, symbol: string, totalSupply: number): FungibleToken {
return new FungibleToken(name, symbol, totalSupply);
}

createNonFungibleToken(name: string, symbol: string, data: any): NonFungibleToken {
return new NonFungibleToken(name, symbol, data);
}

createSmartContract(code: string, language: string): SmartContract {
if (language !== 'lua') {
throw new Error('Only LUA is supported for smart contracts on MoltenChain');
}
return new SmartContract(code, language);
}
}

const magma = new MAGMA();

const myFungibleToken = magma.createFungibleToken('My Token', 'MTK', 100);
const myNonFungibleToken = magma.createNonFungibleToken('My Collectible', 'MTC', { rarity: 'rare' });
const mySmartContract = magma.createSmartContract('print("Hello, MoltenChain!")', 'lua');

Storing MoltenChain records to the cloud

import { Storage } from '@google-cloud/storage';

// Function to save records to the cloud storage for the MoltenChain blockchain async function saveRecords(records: any[], bucketName: string): Promise {

// Create a client for interacting with the Google Cloud Storage API

const storage = new Storage();

// Get a reference to the specified bucket

const bucket = storage.bucket(bucketName);

// Convert the records to a JSON string

const json = JSON.stringify(records);

// Create a new file in the bucket with the JSON data await bucket.file('molten_chain_records.json').save(json); }

// Example usage:

const records = [ { name: 'Alice', age: 25 }, { name: 'Bob', age: 30 }, { name: 'Charlie', age: 35 }, ]; saveRecords(records, 'molten_chain_records_bucket').then(() => { console.log('Records saved successfully'); }).catch((error) => { console.error(error); });

Local MoltenChain records

import { writeFileSync } from 'fs';

// Function to save records to an external storage location for the MoltenChain blockchain

function saveRecords(records: any[], filePath: string): void {

// Convert the records to a JSON string

const json = JSON.stringify(records);

// Save the JSON to the specified file path

writeFileSync(filePath, json); }

// Example usage:

const records = [ { name: 'Alice', age: 25 }, { name: 'Bob', age: 30 }, { name: 'Charlie', age: 35 }, ]; saveRecords(records, '/path/to/molten_chain_records.json');

MoltenChain Smart Contracts in LUA

Here is an example of a token-locking smart contract for MoltenChain written in LUA.

-- Smart contract for token locking mechanism on the MAGMA cryptocurrency on the MoltenChain blockchain

-- Define variables

local tokensLocked = 0

-- Number of tokens currently locked

local lockDuration = 86400 -- Duration of lock in seconds (86400 seconds = 1 day) local lockStartTime = 0 -- Timestamp of when the lock began

-- Function to lock tokens

function lockTokens(numTokens: number) if numTokens < 0 then error("Number of tokens to lock must be a positive integer") end tokensLocked = tokensLocked + numTokens lockStartTime = os.time() end

-- Function to unlock tokens

function unlockTokens(numTokens: number) if numTokens < 0 then error("Number of tokens to unlock must be a positive integer") end if numTokens > tokensLocked then error("Cannot unlock more tokens than are currently locked") end if os.time() < lockStartTime + lockDuration then error("Tokens cannot be unlocked until the lock duration has expired") end tokensLocked = tokensLocked - numTokens end

-- Function to check current number of locked tokens

function getLockedTokens() return tokensLocked end

-- Function to check lock duration

function getLockDuration() return lockDuration end

-- Function to check lock start time

function getLockStartTime() return lockStartTime end

MAGMA-Bot | Main module includes the entire SULFUR ecosystem, multiplayer games like Tic Tac Toe, Rock Paper Scissors, Chess, Mini Battles, The Walking Dead, and many more.

A full blown casino with a slot machine, poker, 3 card poker, blackjack, craps, roulette, and more.

Single player games like Demon Tree, My Storyline, and more.

Run contests, trivias, giveaways, lotteries and more.

Daily rewards, and weekly lootboxes based on role level.

Hire a hitman to kill another user and remain anonymous, pay the hitman in SULFUR.

Exchange system, you will need to purchase MAGMA for your server to have the capability to exchange SULFUR to MAGMA.

To buy MAGMA for your server exchange, please join the MAGMA Discord Server at https://discord.magm.red.

MAGMA-Bot Moderation | A complete moderation and administration bot with custom commands, a punishment system with jail, parole and fines. An execution command to ban jailed members.

A complete verification system designed to protect your members from scammers and prevent your server from getting spammed.

eXP leveling system that automatically rewards users with new roles that earn higher SULFUR rewards.

A complete admin panel, and mods also, based on the role if admin, admin tools will be available in the panel. If the user has a moderation role, they will have a moderators panel.

MAGMA-BOT Members | The member's module offers a unique experience to the server by adding various commands that allow members to take actions against each other weather good or bad. For example you could give someone a hug, or a slap.

MAGMA-Bot Helpers | Is adding additional options such as full documentation of commands and a command to setup the roles, channels, categories, MAGMA wallets, permissions. Bot traps, anf much more.

enables future features like global functions in leaderboards, and rewarding top communities with MAGMA every week.

Cross server events and competitions, plus much more.

MAGMA sets out to be a beacon for independents, independent musicians, independent content creators, independent game devs, independent artists, and so much more.

We wanted to create a community for creative individuals and a platform for them to monetize their ideas and creations.

To better understand what we are trying to accomplish, here are some of our products that will utilized MAGMA, offering quick low cost payments across the world.

Explode is our streaming service currently is a proof of concept, allows independent musicians and pod-casters to publish their recordings on the Explode platform. Fans listening can tip the artist, and instantly send MAGMA directly to the artist, all non custodial and peer to peer.

The Verse is a virtual multiverse platform featuring the world of Lairiah and uses MAGMA for the economy. Explode is streaming inside The Verse, exposing the independent musicians and pod-casters to even more potential fans.

The Verse has many ways MAGMA is being used, things like:

1. Buying, leasing and selling property
2. Developing and designing 3d games and minting custom NFTs as in game content.
3. Create digital experiences
4. Own a virtual business or bring you business virtual.
5. What you can create is only limited by your imagination.

MAGMA was first minted on the Algorand blockchain and is currently available on the Algorand blockchain.