Antlia Ecosystem

Dapp Developers

Dapp Developers

Validator

Validator

Investors

Investors

Government/ Enterprises

Government/ Enterprises

Academia

Academia

Consensus Engine

Rollover Proof Of Stake (PoS) Consensus Algorithm

Antlia has proposed an approach to consensus called Rollover Proof of Stake “rPoS” and its consensus engine is modified tendermint “PBFT”.
Antlia rPoS consensus engine selects the validator nodes on the basis of 10% roll over after every 5 blocks.

Read more Rollover PoS Consensus

Antlia Interoperable Blockchain

Blockchains are not only different because of their consensus but blockchain have different architecture design, many languages and framework to program, and different transaction structure.

Read more Interoperable
Interoperable Interoperate Data interoperability Interoperability in software engineering Database interoperability Enterprise interoperability Digital interoperability Global interoperabilityInteroperable Interoperate Data interoperability Interoperability in software engineering Database interoperability Enterprise interoperability Digital interoperability Global interoperability

use near_sdk::{near_bindgen, env};

#[near_bindgen]
#[derive(Default, BorshDeserialize, BorshSerialize)]
pub struct StatusMessage {
    records: HashMap<String, String>,
}

#[near_bindgen]
impl StatusMessage {
    pub fn set_status(&mut self, message: String) {
        let account_id = env::signer_account_id();
        self.records.insert(account_id, message);
    }

    pub fn get_status(&self, account_id: String) -> Option<String> {
        self.records.get(&account_id).cloned()
    }
}
                    

            const Web3 = require('web3');
            const fs = require('fs');
            const solc = require('solc');
            
            /*
            * connect to ethereum node
            */ 
            const ethereumUri = 'http://localhost:8540';
            const address = '0x004ec07d2329997267Ec62b4166639513386F32E'; // user
            
            let web3 = new Web3();
            web3.setProvider(new web3.providers.HttpProvider(ethereumUri));
            
            if(!web3.isConnected()){
                throw new Error('unable to connect to ethereum node at ' + ethereumUri);
            }else{
                console.log('connected to ehterum node at ' + ethereumUri);
                let coinbase = web3.eth.coinbase;
                console.log('coinbase:' + coinbase);
                let balance = web3.eth.getBalance(coinbase);
                console.log('balance:' + web3.fromWei(balance, 'ether') + " ETH");
                let accounts = web3.eth.accounts;
                console.log(accounts);
            }
            
            /*
            * Compile Contract and Fetch ABI
            */ 
            let source = fs.readFileSync("./contracts/BasicToken.sol", 'utf8');
            
            console.log('compiling contract...');
            let compiledContract = solc.compile(source);
            console.log('done');
            
            for (let contractName in compiledContract.contracts) {
                // code and ABI that are needed by web3 
                // console.log(contractName + ': ' + compiledContract.contracts[contractName].bytecode);
                // console.log(contractName + '; ' + JSON.parse(compiledContract.contracts[contractName].interface));
                var bytecode = compiledContract.contracts[contractName].bytecode;
                var abi = JSON.parse(compiledContract.contracts[contractName].interface);
            }
            
            console.log(JSON.stringify(abi, undefined, 2));
            
            /*
            * deploy contract
            */ 
            let gasEstimate = web3.eth.estimateGas({data: '0x' + bytecode});
            console.log('gasEstimate = ' + gasEstimate);
            let MyContract = web3.eth.contract(abi);
            console.log('deploying contract...');
            let myContractReturned = MyContract.new( {
                from: address,
                data: '0x'+ bytecode,
                gas: gasEstimate + 50000
            }, function (err, myContract) {
                if (!err) {
                    // NOTE: The callback will fire twice!
                    // Once the contract has the transactionHash property set and once its deployed on an address.
// Note that the returned "myContractReturned" === "myContract",
                    // so the returned "myContractReturned" object will also get the address set.
                } else {
                    console.log(err);
                }
            });
            
            (function wait () {
                setTimeout(wait, 1000);
            })();   
                    

package main

import (
    "fmt"
    "github.com/hyperledger/fabric/core/chaincode/shim"
    "github.com/hyperledger/fabric/protos/peer"
)

// SampleChaincode implements a simple chaincode to manage an asset
type SampleChaincode struct {

}

// Init is called during chaincode instantiation to initialize
// data. We'll be adding more in this function later on.
func (t *SampleChaincode) Init(stub shim.ChaincodeStubInterface) peer.Response {
    // Get the args from the transaction proposal
    args := stub.GetStringArgs()
    if len(args) != 2 {
        return shim.Error("Incorrect arguments. Expecting a key and a value")
    }

    // Set up any variables or assets here by calling stub.PutState()

    // We store the key and the value on the ledger
    err := stub.PutState(args[0], []byte(args[1]))
    if err != nil {
        return shim.Error(fmt.Sprintf("Failed to create asset: %s", args[0]))
    }
    return shim.Success(nil)
}

// Invoke is called per transaction on the chaincode. Each transaction is
// either a 'get' or a 'set' on the asset created by Init function. The Set
// method may create a new asset by specifying a new key-value pair.
func (t *SampleChaincode) Invoke(stub shim.ChaincodeStubInterface) peer.Response {
    // Extract the function and args from the transaction proposal
    fn, args := stub.GetFunctionAndParameters()

    var result string
    var err error
    if fn == "set" {
        result, err = set(stub, args)
    } else { // assume 'get' even if fn is nil
        result, err = get(stub, args)
    }
    if err != nil {
        return shim.Error(err.Error())
    }

    // Return the result as success payload
    return shim.Success([]byte(result))
}

// Set stores the asset (both key and value) on the ledger. If the key exists,
// it will override the value with the new one
func set(stub shim.ChaincodeStubInterface, args []string) (string, error) {
    if len(args) != 2 {
        return "", fmt.Errorf("Incorrect arguments. Expecting a key and a value")
    }

    err := stub.PutState(args[0], []byte(args[1]))
    if err != nil {
        return "", fmt.Errorf("Failed to set asset: %s", args[0])
    }
    return args[1], nil
}

// Get returns the value of the specified asset key
func get(stub shim.ChaincodeStubInterface, args []string) (string, error) {
    if len(args) != 1 {
        return "", fmt.Errorf("Incorrect arguments. Expecting a key")
    }

    value, err := stub.GetState(args[0])
    if err != nil {
        return "", fmt.Errorf("Failed to get asset: %s with error: %s", args[0], err)
    }
    if value == nil {
        return "", fmt.Errorf("Asset not found: %s", args[0])
    }
    return string(value), nil
}

// main function starts up the chaincode in the container during instantiate
func main() {
    err := shim.Start(new(SampleChaincode))
    if err != nil {
        fmt.Println("Could not start SampleChaincode")
    } else {
        fmt.Println("SampleChaincode successfully started")
    }
}
           

Antlia Virtual Machine (VM) with developing tools

Antlia is a turing complete blockchain embedded with a VM to write smart contracts in web assembly. Antlia VM has a series of tooling to help developers community.

Read more Antlia VM with Dev tools

Oracle with Trusted Smart Contracts

Antlia oracles are built using web assembly based smart contracts. Antlia oracles can facilitate the transparent and trussless execution of smart contracts to bring data in and out of blockchain.

Read more Smart Contract
Circle
Smart ContractSmart ContractSmart Contract

ANA Coin The Native Coin of Antlia

The ANA Coin is a unit of value that is native to the Antlia Blockchain. ARC based token can be generated using WASM based smart contract at Antlia Blockchain. Any asset can be used for the gas and rewards for staking. Currently, ANA coin will be used for Gas and staking purpose at Antlia Blockchain Network.

Governance

Governance

Stacking

Stacking

Transactions

Transactions

Smart Contracts

Smart Contracts

Validator Rewards

Validator Rewards

Looking Forward | Technical Roadmap

Antlia is all set to launch its validator staking program by the end of 2021. The detailed roadmap shows us the milestones from an alpha release through to multiple betas and a targeted mainnet release.

Release 1:

Antlia StakeFlow will be releasing a new open source alpha testnet built to be compatible with a new 2.0 platform that anyone can run a node in.

Release 2:

Launching of the live beta of a fully functional StakeFlow Staking App 1.0 with complete UI for staking of ETH2.0, receiving Synthetic anaETH2, Synthetic Rewards, and on-chain governance.

Release 3:

Following the launch of the live beta of StakeFlow Staking App, complete audits from multiple sources will be conducted and feature freeze will be implemented to check the performance of the smart contracts.

Release 4:

After successful audits of StakeFlow Staking, designing of a new user interface of synthetic investment/borrowing of digital crypto assets and liquidity pools will be conducted. Addition of the DeFi features in the StakeFlow beta app.

Release 5:

Launching of the live beta of StakeFlow DeFi App 2.0 with added DeFi features. The beta 2.0 provides full ability to perform transactions in multiple sections within the app. Objective to test the beta 2.0 with over 500+ node operators having more than 800,000 testnet ETH circulating around the app.

Release 6:

Rigorous multiple audits of beta 2.0 will be conducted, checking the ability of the app to handle thousands of transactions. Both smart contracts and the DeFi ecosystem will be audited.

Release 7:

Following the successful completion of the multiple audits of beta 2.0, Antlia Stakeflow will be released to the mainnet. Users can engage in the Antlia DeFi ecosystem and perform transactions in a trustless manner.

Media

Bitcoin
Business Insider
Coin Telegraph
Crypto News
Market Watch
Yahoo inance

Our Partners

Creative Destruction Lab
RNS Solutions
Trusted Chain