Hire ReactJS Developers | ReactJS Development

Creating a Custom Hyperliquid Dashboard: Track Live Holdings in React As the demand for decentralized derivatives exchange grows, platforms likeHyperliquid are becoming the go-to for real-time perpetual trading. If you're building a Web3 frontend or crypto portfolio tracker, showinglive token holdings directly from Hyperliquid can dramatically improve your user experience.In this guide, we'll walk you through building acustom Hyperliquid trading dashboard in React. You'll learn how to fetch and display a user's real-time balances using a clean component-based architecture.What is Hyperliquid?Hyperliquid is a high-performance, decentralized perpetual exchange offering instant finality, low fees, and composable APIs. As a trader, you can access dozens of markets with lightning-fast performance. As a developer, you can use their APIs to build dashboards, bots, and analytics tools.By integrating Hyperliquid data, you can:Fetch real-time token balances from any Hyperliquid addressBuild portfolio dashboards and analytics chartsProvide wallet-based trading interfacesAlso, Check | How to Fetch Token Pricing with On-Chain Bonding CurvesPrerequisitesBefore you start building the dashboard, ensure you have the following ready:A basic understanding of React.jsNode.js and npm/yarn installedA Hyperliquid wallet address for testingTailwind CSS or your preferred styling library (optional)Step 1: Set up Your React AppFirst, let's set up your React app if you haven't done so already:We'll useVite for lightning-fast development:# 1. Create your Vite + React project npm create vite@latest hyperliquid-dashboard -- --template react # 2. Navigate into the project folder cd hyperliquid-dashboard # 3. Install dependencies npm install # 4. Start the dev server npm run devNow, install any required packages:npm install wagmi viem @tanstack/react-query @rainbow-me/rainbowkitNOTE:Now, you'll need to set up a wallet connection usingwagmi. You can follow theWagmi Quick Start Guide for configuring your wallet connection.Also, Explore | Build a Crypto Payment Gateway Using Solana Pay and ReactStep 2: Fetch Holdings DataLet's start with the custom hook to get holdings from the Hyperliquid testnet API.// components/useHyperLiquidHoldings.jsx import { useEffect, useState } from "react"; import { useAccount } from "wagmi"; export const useHyperliquidHoldings = () => { const [holdings, setHoldings] = useState(null); const [loading, setLoading] = useState(false); const { address } = useAccount(); useEffect(() => { if (!address) { setHoldings(null); setLoading(false); return; } const fetchHoldings = async () => { setLoading(true); try { const response = await fetch("https://api.hyperliquid-testnet.xyz/info", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify({ type: "spotClearinghouseState", user: address, //for testing use can use the any address like zero address 0x0000000000000000000000000000000000000000 }), }); const data = await response.json(); setHoldings(data); } catch (error) { console.error("Error fetching holdings:", error); } finally { setLoading(false); } }; fetchHoldings(); }, [address]); return { holdings, loading }; };Step 3: Create the Holdings TableNext, build a responsive table UI to display the balances.// components/HoldingTable.jsx export default function HoldingsTable({ balances }) { return ( <div className="table-container"> <h2 className="table-title">Your Token Balances</h2> <div className="table-wrapper"> <table className="responsive-table"> <thead> <tr> <th>Coin</th> <th>Token ID</th> <th>Hold</th> <th>Total</th> <th>Entry Notional</th> </tr> </thead> <tbody> {!balances || balances.length === 0 ? ( <tr> <td colSpan="5" className="no-data"> No balances available. </td> </tr> ) : ( balances.map((item, i) => ( <tr key={i}> <td>{item.coin}</td> <td>{item.token}</td> <td>{item.hold}</td> <td>{item.total}</td> <td>{item.entryNtl}</td> </tr> )) )} </tbody> </table> </div> </div> ); }Also, Discover | Create DeFi Index Fund with Custom ERC-4626 Tokenized VaultsStep 4: Build the NavbarAdd a simple navbar component for reusable top navigation.// components/Navbar.jsx import { ConnectButton } from "@rainbow-me/rainbowkit"; import React from "react"; function Navbar() { return ( <div className="navbar"> <h1 className="logo">HYPER LIQUID</h1> <ConnectButton /> </div> ); } export default Navbar;Step 5: Set up ProvidersIf you're planning to expand later (like wallet integration), create a Providers wrapper.// components/Provider.jsx import { WagmiProvider } from "wagmi"; import { RainbowKitProvider, darkTheme, getDefaultConfig, } from "@rainbow-me/rainbowkit"; import "@rainbow-me/rainbowkit/styles.css"; import { QueryClient, QueryClientProvider } from "@tanstack/react-query"; const hyperLiquidChain = { id: 998, name: "Hyper Liquid", nativeCurrency: { name: "Hyper Liquid", symbol: "HYPE", decimals: 18 }, rpcUrls: { default: { http: ["https://rpc.hyperliquid-testnet.xyz/evm"] }, }, }; const config = getDefaultConfig({ chains: [hyperLiquidChain], projectId: "3c81036dac8bb5451ee3e10fd92ea0e0", }); const queryClient = new QueryClient(); function Providers({ children }) { return ( <WagmiProvider config={config}> <QueryClientProvider client={queryClient}> <RainbowKitProvider theme={darkTheme({ overlayBlur: "small", borderRadius: "medium", })} modalSize="compact" > {children} </RainbowKitProvider> </QueryClientProvider> </WagmiProvider> ); } export default Providers;Also, Check | Decentralized Prediction Market Development on EthereumStep 6: Compose the AppHere's how your main app logic comes together:// App.jsx import HoldingsTable from "./components/HoldingTable"; import Navbar from "./components/Navbar"; import { useHyperliquidHoldings } from "./components/useHyperLiquidHoldings"; function App() { const { holdings } = useHyperliquidHoldings(); return ( <div> <Navbar /> <div className="holding-section"> <HoldingsTable balances={holdings?.balances} /> </div> </div> ); } export default App;And entry point:// main.jsx import { StrictMode } from "react"; import { createRoot } from "react-dom/client"; import "./index.css"; import App from "./App.jsx"; import Providers from "./components/Provider.jsx"; createRoot(document.getElementById("root")).render( <StrictMode> <Providers> <App /> </Providers> </StrictMode> );Step 7: Add a simple index.css file* { margin: 0; padding: 0; box-sizing: border-box; font-family: sans-serif; } .navbar { width: 100%; padding: 10px 20px; border: 1px solid black; display: flex; align-items: center; justify-content: space-between; } .holding-section { padding: 50px; } .table-container { padding: 1rem; background-color: #1a1a1a; color: #fff; border-radius: 8px; margin-top: 20px; max-width: 100%; overflow-x: auto; } .table-title { font-size: 1.5rem; font-weight: 600; margin-bottom: 1rem; text-align: center; } .table-wrapper { overflow-x: auto; } .responsive-table { width: 100%; border-collapse: collapse; min-width: 600px; } .responsive-table th, .responsive-table td { padding: 12px 16px; text-align: left; border-bottom: 1px solid #333; } .responsive-table th { background-color: #2a2a2a; font-weight: 600; } .responsive-table tr:hover { background-color: #333; } .no-data { text-align: center; color: #ccc; padding: 1rem; }Step 8: Run and TestMake sure to:Replace the test wallet address inuseHyperLiquidHoldings.jsxStyle your components inindex.css or using TailwindOpen your app onhttp://localhost:5173 and view live balancesConclusionYou've just built a functional Hyperliquid dashboard that fetches and displays live wallet holdings. With this foundation, you can extend your app to support:Wallet connection via MetaMaskReal-time trade executionPnL trackingHistorical analyticsThis kind of integration gives you powerful insights into decentralized trading activities and is a stepping stone toward building full-featured Web3 trading interfaces.OutputIf you are planning to build a deFi protocol or deFi exchange like Hyperliquid, connect with our skilled blockchain developers to get started.

Technology: TAILWIND CSS , Node Js more Category: Blockchain Development & Web3 Solutions

Rohit Kumar Gola

07 Jul 2025

How to Place a Limit Order on Ethereum using Kyberswap In this guide, we will walk through the process of placing a limit order on Kyberswap using their API. Kyberswap is a decentralized exchange (DEX) aggregator that provides the best token prices by aggregating liquidity from various DEXs. By leveraging Kyberswap's API, we can automate the process of placing limit orders for token trades, giving you full control over your trade price. This tutorial will guide you through setting up the necessary environment, writing the code to interact with the Kyberswap API, and successfully placing a limit order using Node.js and the appropriate dependencies. For more about DEX, visit crypto exchange development services.What is a limit order?A limit order is an instruction to buy or sell your token at a specific price or better. It gives control over the trade price to be executed.For example:A buy limit order will only execute at the limit price. And a sell limit order will only execute at the limit price or higher.Also Read | Ethereum Smart Contracts: Best Use CasesWhat is Kyberswap?A dex aggregator & liquidity protocol that provides the best token price by aggregating liquidity from various DEXs. It also provides liquidity providers with opportunities to earn rewards by depositing their tokens.Before everything, you must have Node.js and VS Code installed.Let's set up this:Open your terminal and type this command: 1. mkdir KyberswapApi 2. cd KyberswapApi 3. code .It will open your project KyberswapApi in VS Code, then open the terminal in VS Code and type this command: npm init It will initialize a project and create the package.json file. npm install viem ethers axios It will install all dependencies in your package.json file.Create a file index.js and paste this ProgramRun this command in your terminal : node index.js (this will create the limit order successfully).Also, Read | A Dev Guide to Placing Orders using Hyperliquid APIHow to use Kyberswap Api to place a limit orderTo create a new order, we need to make a post request on this URL: https://limit-order.kyberswap.com/write/api/v1/ordersFor this, we need params which include the signed EIP712 message and returned data from this post request(https://limit-order.kyberswap.com/write/api/v1/orders/sign-message).Program : import { createWalletClient, erc20Abi, parseEther, getContract, createPublicClient, http, encodeFunctionData } from "viem"; import { ethers } from "ethers"; import axios from "axios"; import { privateKeyToAccount } from 'viem/accounts'; import { base } from 'viem/chains'; const kyberApiUrl = "https://limit-order.kyberswap.com"; const privateKey = "000000X4PRivateKey"; const rpcUrl = "https://mainnet.base.org"; async function mainApprove(makerAsset, limitOrderContract, maker, makingAmount) { const client = createPublicClient({ chain: { id: 8453, // Base chain ID name: "Base", rpcUrls: { default: { http: ["https://mainnet.base.org"] }, }, }, transport: http("https://mainnet.base.org") }); console.log("Client created for Base chain:", client); const tokenContract = getContract({ abi: erc20Abi, address: makerAsset, client: client, }); console.log("here is the tokenContract",tokenContract.address); const currentAllowance = await tokenContract.read.allowance([ maker, limitOrderContract, ]); console.log("Current Allowance:", currentAllowance.toString()); const encodedCalls = []; if (BigInt(currentAllowance) < BigInt('100000000')) { console.log("here it comes "); const approvalData =await getTokenApprovalCalldata( makerAsset, limitOrderContract, makingAmount, ); console.log(' Approval Data:', approvalData); encodedCalls.push({ to: makerAsset , data: approvalData, // gas: '0.007547422' //approvalGas.toString(), }); console.log("Encoded Calls:", encodedCalls); const swaptx = encodedCalls; const str = "000000X4PRivateKey"; const account = privateKeyToAccount(`0x${str}`); const walletClient = createWalletClient({ account, chain: base, transport: http('https://mainnet.base.org'), }); console.log("Wallet Client created:"); const tx1=[]; for (const call of swaptx) { const tx = { to: call.to, data: call.data, value: call.value ? BigInt(call.value) : 0n, }; const hash = await walletClient.sendTransaction(tx); tx1.push(hash); console.log(' Transaction sent, hash:', hash); } return tx1; } return ""; } async function postCreateOrderUnsigned( chainId, makerAsset, takerAsset, maker, //Maker address makingAmount, // "10000" takingAmount // "20000000000000000" ) { let targetPath = `/write/api/v1/orders/sign-message`; // Structure the request to be sent in POST body const requestBody = { chainId: chainId.toString(), makerAsset: makerAsset, // USDC takerAsset: takerAsset, // KNC maker: maker, allowedSenders: [maker], // Included so that only our account can fill this order makingAmount: makingAmount, takingAmount: takingAmount, expiredAt: Math.floor(Date.now() / 1000) + 60 * 60, // 60mins }; console.debug(requestBody); try { const { data } = await axios.post(kyberApiUrl + targetPath, requestBody); // Return the request used and the EIP712 unsigned data console.log("the data we have",data); return { routerContract: data.data.domain.verifyingContract, requestBody: requestBody, returnedData: data.data, }; } catch (error) { throw error; } } //Get Maker Active Making Amount async function getMakerActiveAmount(chainId, makerAsset, makerAddress) { const targetPath = `/read-ks/api/v1/orders/active-making-amount`; const targetPathConfig = { params: { chainId: chainId, makerAsset: makerAsset, maker: makerAddress, }, }; try { const { data } = await axios.get( kyberApiUrl + targetPath, targetPathConfig ); return data.data.activeMakingAmount; } catch (error) { throw error; } } async function getContracts(chainId) { const targetPath = `/read-ks/api/v1/configs/contract-address`; // Specify the chainId to query const targetPathConfig = { params: { chainId: chainId.toString(), }, }; try { console.log(`\nGetting the LO contracts...`); const { data } = await axios.get( kyberApiUrl + targetPath, targetPathConfig ); return data.data; } catch (error) { throw error; } } // Request approval with calldata sending to the user server (client-side) async function getTokenApprovalCalldata( tokenContractAddress, spenderAddress, amount ) { const data = encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [spenderAddress, parseEther(amount.toString())], }); //TODO: Send the calldata to the user server here return data; } async function signOrderData(domain, types, message) { const provider = new ethers.JsonRpcProvider(rpcUrl); const signer = new ethers.Wallet(privateKey, provider); return await signer.signTypedData(domain, types, message); } // Create New Order on Kyberswap async function postCreateOrder( chainId, makerAsset, takerAsset, maker, makingAmount, takingAmount ) { const targetPath = `/write/api/v1/orders`; const unsignedOrder = await postCreateOrderUnsigned( chainId, makerAsset, takerAsset, maker, makingAmount, takingAmount ); // Get the request body and the EIP712 order creation data const unsignedOrderReqBody = unsignedOrder.requestBody; const unsignedOrderReturnData = unsignedOrder.returnedData; const routerContract = unsignedOrder.routerContract; // Get the Maker current making amount to ensure contract has sufficient allowance across all orders const currentMakingAmount = await getMakerActiveAmount( chainId, makerAsset, maker ); const newMakingAmount = Number(currentMakingAmount) + Number(unsignedOrderReqBody.makingAmount); // Get the LO contract address to interact with on-chain const limitOrderContract = (await getContracts(chainId)).latest; // Check if LO contract has sufficient allowance to spend makerAsset await getTokenApprovalCalldata( makerAsset, limitOrderContract, newMakingAmount ); const swaptx= await mainApprove( makerAsset, limitOrderContract, maker, newMakingAmount ) console.log("the swaptx is: ",swaptx); // Sign the EIP712 order creation with the user server (client-side) const signature = await signOrderData( unsignedOrderReturnData.domain, { Order: unsignedOrderReturnData.types.Order }, unsignedOrderReturnData.message ); // Structure the request to be sent in POST body const requestBody = { ...unsignedOrderReqBody, salt: unsignedOrderReturnData.message.salt, signature: signature, }; console.log("the request body is: ", requestBody); try { console.log(`\nPosting the create order...`); const { data } = await axios.post(kyberApiUrl + targetPath, requestBody); console.log(`KyberSwap server response:`); console.log(data); } catch (error) { throw error; } }Call the post createOrder function with its parameters, and your order will be created.For example : postCreateOrder( "8453", // chainId "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb", // maker asset "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913", // taker asset "0x1AC9b76006BaF4f06563E491d4182C82792D2A2C", // maker address "5000000", // making amount "5000000" // taking amount );You may also like | Building a Portfolio Tracker Dashboard Using Hyperliquid APIConclusion:In conclusion, this guide demonstrates how to place a limit order on Kyberswap using the API, allowing you to efficiently manage trades with full control over your order price. By following the steps to set up your environment, configure your wallet, and interact with the Kyberswap API, you can easily integrate limit orders into your trading strategies. With the right parameters and authentication, you can securely create orders on Kyberswap and take advantage of the liquidity available. This process enables developers to enhance their algorithmic trading systems and automate transactions effectively on the platform. For more information, refer to the Kyberswap API documentation.In case you are planning to build a DEX aggregator like Kyberswap, connect with our skilled blockchain developers to get started.

Technology: ReactJS , Node Js more Category: Blockchain Development & Web3 Solutions

Krishan Chand

06 Jul 2025

How to Fetch Transaction History on Ethereum using Web3.py One of the most popular blockchain systems, Ethereum, enables token trading, smart contract development, and the development of decentralised apps (DApps). Retrieving transaction history for a specific address is a crucial component of any blockchain. Web3.py is a well-liked Python toolkit for Ethereum developers to communicate with the Ethereum blockchain. We'll demonstrate how to use Web3.py to retrieve Ethereum transaction history in this blog post.What is Web3.py?Web3.py is a Python library that enables interaction with the Ethereum blockchain. It enables developers to send transactions, communicate with smart contracts, query the blockchain, and much more. Web3.py is frequently used in Ethereum-based DApps and blockchain development to facilitate blockchain interactions using Python.Why Fetch Transaction History?One essential function of any blockchain explorer, wallet app, or DApp is the ability to retrieve transaction history. Obtaining transaction information allows you to:Track and monitor transactions.Obtain details about tokens sent or received.Examine an address's activity for reporting or auditing needs.Also, check | Develop a Multi-Token Crypto Wallet for Ethereum with Web3.jsSteps to Fetch Ethereum Transaction History1. Set Up Web3.py:Installing Web3.py and configuring the connection to an Ethereum node pip install web32. Connecting to the Ethereum Network:Web3.py must be connected to an Ethereum node in order to communicate with the Ethereum blockchain. Infura is a popular solution for this, offering an Ethereum access API. For this, you will want an Infura project ID.Also, Discover | Developing Cross-Platform Crypto Wallet with Web3.js & React from web3 import Web3 infura_url = 'https://mainnet.infura.io/v3/your infura api key' web3 = Web3(Web3.HTTPProvider(infura_url)) # Check if connected if web3.is_connected(): print("Connected to Ethereum Network") else: print("Failed to connect to Ethereum Network")3. Fetch Transaction History:def get_transaction_history(address, start_block=0, end_block='latest'): address = web3.to_checksum_address(address) # Ensure address is in checksum format transactions = [] # Define block range end_block = web3.eth.block_number if end_block == 'latest' else int(end_block) # Loop through blocks and fetch transactions for block_number in range(start_block, end_block + 1): block = web3.eth.get_block(block_number, full_transactions=True) print(f"Processing block {block_number}") if block and block.transactions: for txn in block.transactions: # Check if the transaction involves the target address if txn['to'] == address or txn['from'] == address: transactions.append(txn) return transactions # Replace with the address you're querying transactions = get_transaction_history('0xYourEthereumAddressHere', start_block=10000000, end_block=str(10001000)) # Display transaction details for txn in transactions: print(f"Transaction Hash: {txn['hash'].hex()}") print(f"From: {txn['from']}") print(f"To: {txn['to']}") print(f"Amount: {web3.from_wei(txn['value'], 'ether')} ETH") print(f"Block Number: {txn['blockNumber']}") print(f"Gas Used: {txn['gas']}") print('---')Output:  Environment updated. Reloading shell... Connected to Ethereum Network Processing block 21873279 Processing block 21873280 Processing block 21873281 Processing block 21873282 Processing block 21873283 Processing block 21873284 Transaction Hash: 650b635c2687df8103a3df0ede497e0ff12fb3041494adf031debc7b61e8223c From: 0x8D9903956d0C9bE104E4Ed32852080F86cfCadcF To: 0x66a9893cC07D91D95644AEDD05D03f95e1dBA8Af Amount: 0 ETH Block Number: 21873279 Gas Used: 351949 ---Also Read | Ethereum Smart Contracts: Best Use CasesConclusionFetching Ethereum transaction history using Web3.py empowers developers to build robust blockchain applications with transparency and accountability. Whether you're developing a wallet, an audit tool, or an analytics dashboard, accessing historical transaction data is key to understanding user behavior, ensuring compliance, and enabling seamless experiences. With just a few lines of Python and a connection to an Ethereum node like Infura, you can easily retrieve and analyze on-chain activity, making Web3.py an essential tool in every Ethereum developer's toolkit.If you're looking to build or scale blockchain solutions, feel free to connect with our experienced blockchain developers for tailored development support.

Technology: ANGULAR , ReactJS more Category: Blockchain Development & Web3 Solutions

Rahul Maurya

12 Jun 2025

How to Build and Launch Token Swaps on Movement Blockchain With the Movement Mainnet as their main product, Movement Labs is building a network of blockchains based on Move. With the Move programming language, this blockchain offers high transaction throughput (TPS) while prioritizing community interaction. It provides freedom for modular adaptations, quick finality, and native access to liquidity right now. Utilizing Facebook's Move language, the platform's design places a strong emphasis on safety and ownership. Because Move represents assets as resources, it is easier and safer to implement smart contracts for typical blockchain operations like asset destruction, minting, and transfer. The white paper delves deeper into the technological solutions, while the documentation presents the Movement Mainnet's goal. To know more about developing on other blockchains, visit blockchain app development services.Features of the Movement Blockchain:160K+TPS with MoveVM's parallel execution. Fast finality ensures quick transaction confirmation for real-time apps like games and DePIN.Minimal transaction costs, ideal for micro transactions and high-frequency use cases like gaming and IoT.Move language prevents vulnerabilities and ensures asset safety. Formal verification with Move Prover enhances contract security.Custom rollups for specific use cases. Modular architecture allows easy integration of new features.Shared sequencers enable cross-chain transactions and pooled liquidity. Dual compatibility supports both MoveVM and EVM bytecode for Move and Solidity contracts.Roll-ups and modular chains prevent congestion, supporting large-scale apps like MMOs or DePIN.Validators stake assets for security, with multi-asset staking promoting decentralization and resilience.You may also like | Developing a Peer-to-Peer Car Rental System on Blockchain (with Code)Workflow of the Movement Network :1. Key Elements :The Fast Finality Settlement Module (fast transaction finality), the Decentralized Shared Sequencer (ensures fair transaction ordering and cross-chain interoperability), and the Move Executor (supports Move VM & EVM byte code) are all elements of Movement Network.2. Life cycle of a TransactionThe Move Executor executes transactions, sequences them, verifies data availability, and uses the Fast Finality Settlement Module to finalize them on Layer 1.3. Staking with multiple assets and interoperabilityMulti-asset staking improves network security and decentralization, while the common decentralized sequencer facilitates cross-chain transactions.4. Move the Arena and the StackIn order to provide quick finality and shared liquidity, the Move Arena enables the deployment of application-specific chains, while the Move Stack offers tools for creating Move-based blockchains.Also, Check | Developing a Blockchain-Based Encrypted Messaging AppReal-World Projects Powered by Movement Blockchain :Seekers AllianceA dynamic multiplayer trading card game that integrates NFT mechanics and a competitive ranked ladder, offering a fresh take on digital card battles.Cryptara ConquestDive into this 2D survival RPG where players can craft items, battle hostile mobs, and make in-game purchases—all on-chain.XenobunnyA PvP strategy card game that merges NFTs, DeFi elements, and user-generated content to create a unique and interactive gaming experience.LaniakeaAn expansive open-world MMORPG featuring customizable characters, 20 unique factions, and over 100 weapons—built for deep, blockchain-enhanced immersion.Also, read | Quantum-Resistant Blockchain App Development Using MochimoSwap Implementation Script:file : InitializeClient.tsimport { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk"; const network = process.env.NETWORK?.toUpperCase() as keyof typeof Network; const config = new AptosConfig({ network: Network[network] || Network.CUSTOM, fullnode: 'https://testnet.bardock.movementnetwork.xyz/v1', indexer: 'https://indexer.testnet.movementnetwork.xyz', }); export const aptosClient = new Aptos(config);This code sets up a connection to the Movement blockchain, which is compatible with Aptos. It uses a testnet fullnode and indexer to enable your app to send transactions, query data, and interact with the blockchain network. This setup is essential for integrating blockchain features into your application.file Migrate.ts fileimport { Account, Ed25519PrivateKey } from "@aptos-labs/ts-sdk"; import { aptosClient } from "./IntializeClient"; const INPUT_FUNCTION = `0x1::coin::migrate_to_fungible_store` as const; (async () => { //Private Key const privateKey = new Ed25519PrivateKey('YOUR PRIVATE KEY'); const account = Account.fromPrivateKey({ privateKey }); //payload to Build Transaction const wrapAptPayload = { function: INPUT_FUNCTION, typeArguments: ['0x1::aptos_coin::AptosCoin'], functionArguments: [], arguments: [], }; //build Transaction const txn = await aptosClient.transaction.build.simple({ sender: account.accountAddress, data: wrapAptPayload, }); //Sign Transaction Using Private Key const signature = await aptosClient.sign({ signer: account, transaction: txn, }); console.log("Signature:..............", signature); //Submit Transaction const commitTxn = await aptosClient.transaction.submit.simple({ transaction: txn, senderAuthenticator: signature, }); console.log("Transaction Submitted:............", commitTxn); // Waiting for Transaction Response const response = await aptosClient.waitForTransaction({ transactionHash: commitTxn.hash, }); console.log("Waiting Response :............", response); })();This script demonstrates how to perform a token migration on the Movement (Aptos-compatible) blockchain. It connects using a private key, builds a transaction for the migrate_to_fungible_store function, signs it, submits it to the network, and waits for the result. This flow is essential for interacting with smart contract functions securely.file Swap.ts :import { aptosClient } from "./IntializeClient"; import { Account, Ed25519PrivateKey, InputGenerateTransactionPayloadData, } from "@aptos-labs/ts-sdk"; const MODULE_ADDRESS = "0xa5c3d8ac06d3e30a2ad5d06ebe2b3f2ace9597b167cf18d61c5263707aa4764b::router::swap_exact_input" as const; (async () => { const privateKey = new Ed25519PrivateKey( "YOUR PRIVATE KEY" ); const account = Account.fromPrivateKey({ privateKey }); try { const payload: InputGenerateTransactionPayloadData = { function: MODULE_ADDRESS, functionArguments: [ "0xa", "YOUR TOKEN ADDRESSS", 'YOUR SWAP AMOUNT', 'YOUR SWAP AMOUNT', ], typeArguments: [], }; const TxnIn = await aptosClient.transaction.build.simple({ sender: account.accountAddress, data: payload, }); console.log("Transaction Built:", TxnIn); const signature = aptosClient.transaction.sign({ signer: account, transaction: TxnIn, }); console.log("Signature Created:", signature); const newTxn = await aptosClient.transaction.submit.simple({ transaction: TxnIn, senderAuthenticator: signature, }); console.log("Transaction Submitted:", newTxn); const response = await aptosClient.waitForTransaction({ transactionHash: newTxn.hash, }); console.log("Transaction Confirmed:", response); } catch (error: any) { console.error("Error in swap transaction:", error.message || error); } })();This script performs a token swap transaction on the Movement blockchain by interacting with a specific smart contract function. It creates a transaction payload with necessary arguments, signs it using a private key, submits the transaction, and waits for confirmation from the network. This process enables executing token swaps securely on the blockchain.Movement Blockchain Explorer: https://explorer.movementnetwork.xyz/?network=bardock+testnet Conclusion:The Move Blockchain is a sophisticated Layer 2 network built on Ethereum that uses the Move Virtual Machine (MoveVM) to provide strong security, cheap fees, and fast throughput. It allows for compatible and scalable dApps by supporting both Move and EVM smart contracts. With its resource-oriented programming style, formal verification, and configurable roll-ups, Movement raises the bar for blockchain security and effectiveness while facilitating wider access to next-generation blockchain development. If you are looking to leverage the potential of the Movement blockchain to develop and launch your project, connect with our skilled blockchain developers to get started. MoveVM adoption is growing across ecosystems like Movement and Sui. Working with a Sui Blockchain Development Company helps you align with emerging standards.

Technology: CLOUDFLARE , GOOGLE CLOUD more Category: Blockchain Development & Web3 Solutions

Tushar Shrivastava

14 May 2025

How to Build and Launch your NFT Collection Non-Fungible Tokens (NFTs) have revolutionized the digital art and collectibles space,providing artists, creators, and developers with new ways to monetize digital assets. Solana, with its high throughput and low transaction costs, has emerged as a popularblockchain for deploying NFTs. This guide will walk you through the step-by-step process of launching an NFT collection on Solana.Why Choose Solana for NFTs?Scalability: Solana can handle over 65,000 transactions per second,making it highly efficient for NFT projects.Low Fees: Transaction costs on Solana are significantly lower compared to Ethereum.Developer-Friendly: Solana provides robust developer tools, including Metaplex and Anchor, to simplify the NFT creation process.Prerequisites:-Before you start, ensure you have the following:A computer with Node.js and Yarn installed.Solana CLI installed and configured.A funded Solana wallet.Metaplex CLI is installed globally.Also, Read | Building a Solana NFT Rarity Ranking ToolStep 1: Set Up Your Solana WalletInstall the Solana CLI:sh -c "$(curl -sSfL https://release.solana.com/v1.14.10/install)" Generate a new wallet: solana-keygen new --outfile ~/.config/solana/id.json Fund the wallet using the Solana devnet faucet: solana airdrop 2Step 2: Create Your NFT Assets and MetadataPrepare your NFT assets and metadata in a structured directory:assets/nft1.png (Your NFT image) assets/nft1.json (Metadata file) Example nft1.json: { "name": "NFT #1", "symbol": "NFTSYM", "uri": "https://arweave.net/your-file", "seller_fee_basis_points": 500, "creators": [{ "address": "YourWalletAddress", "share": 100 }] }Step 3: Upload Assets to Arweave/IPFSInstall Metaplex CLI:yarn global add @metaplex/cli Upload the assets: metaplex upload assets/ Step 4: Create a Umi instanceimport { createUmi } from "@metaplex-foundation/umi-bundle-defaults"; const umi = createUmi(rpcUrl); umi.use(mplTokenMetadata()); umi.use(signerIdentity(currentSigner)); Also, Discover | Building a Cross-Chain NFT Bridge using Solana WormholeStep 5: Create and Mint: NFT collectionimport { createAndMint, TokenStandard, } from "@metaplex-foundation/mpl-token-metadata"; const createTx = await createAndMint(umi, { mint: collection, authority: currentSigner, name: "Collection NFT", symbol: "weenfrens", sellerFeeBasisPoints: percentAmount(0), tokenStandard: TokenStandard.NonFungible, uri: "", amount: 1, isCollection: true, }).sendAndConfirm(umi, { confirm: { commitment: "finalized" } });Step 6: Verify Your NFTsCheck your wallet on the Solana Explorer to verify the NFTs:https://explorer.solana.com/Also, check | How to Create an NFT Rental Marketplace using ERC 4907ConclusionLaunching an NFT collection on Solana is a streamlined process thanks to tools like Metaplex. By following the steps outlined above, you can deploy your NFT assets, mint them, and view them on the blockchain. In case you are looking for professional NFT development services to build and launch your NFT collection, connect with our skilled NFT developers to get started.

Technology: ANGULAR , ReactJS more Category: Blockchain Development & Web3 Solutions

Krishan Chand

09 May 2025

Stablecoin Development with CDP (Collateralized Debt Positions) A decentralized stablecoin is built through specialized crypto token development services and relies on blockchain technology to issue digital assets pegged to a fixed value, such as $1. Unlike traditional currencies, these stablecoins operate without central authority. One of the most widely used models is Collateralized Debt Positions (CDPs), where smart contracts manage the issuance and liquidation process based on collateral. Partnering with an experienced stablecoin development company ensures these mechanisms are designed for security, transparency, and long-term stability.A CDP is a smart contract that, in exchange for granting a loan in the form of stablecoins, locks up collateral, such as Ether. A CDP's salient characteristics are:Collateral: The user funds a smart contract with a specific quantity of cryptocurrency (such as ETH).Debt: Depending on the value of the supplied collateral, the user borrows stablecoins. The collateral ratio (e.g., 150%) restricts the amount of debt that can be borrowed, thus the borrower is not allowed to withdraw more stablecoins than the collateral value.Collateral Ratio: This is the proportion of money loaned in stablecoins to the amount of collateral needed. The borrower must deposit $1.50 in collateral for every $1 borrowed in stablecoin, for instance, if the collateral ratio is 150%.Liquidation: The system will sell the collateral to pay off the debt and keep the system from slipping into negative equity if the collateral's value drops below a predetermined level, meaning it is no longer sufficient to cover the borrowed debt.Repayment: After repaying the debt, the collateral is returned, and the user can do so by returning the stablecoins they borrowed.Also, Discover | AI-Powered Stablecoin Development | Streamlining StabilityStabelcoin Development with CDP (Collateralized Debt Positions)Setup1. Initialize the Projectnpm init -y2. Install Hardhatnpm install --save-dev hardhat3. Create a Hardhat Projectnpx hardhat4. Install Environment and OpenZeppelin Librariesnpm install dotenv @openzeppelin/contractsYou may also like | Best Blockchain Platforms for Stablecoin DevelopmentIn contracts folder add the following three files:1. Usdc.sol– Mock ERC20 StablecoinThis is a sample ERC20 token acting as a mock USDC, used to mint and burn tokens during borrow/repay operations.// SPDX-License-Identifier: MIT pragma solidity ^0.8.22; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; contract USDC is ERC20, Ownable { uint8 private immutable _decimals; address public minter; constructor( string memory name_, string memory symbol_, uint8 decimals_, uint256 initialSupply ) ERC20(name_, symbol_) Ownable(msg.sender) { _decimals = decimals_; _mint(msg.sender, initialSupply); } function setMinter(address _minter) external onlyOwner { minter = _minter; } function mint(address to, uint256 amount) external { require(msg.sender == minter, "Only minter can mint"); _mint(to, amount); } function burn(address from, uint256 amount) external { require(msg.sender == minter, "Only minter can burn"); _burn(from, amount); } function decimals() public view override returns (uint8) { return _decimals; } }2. Oracle.sol– Mock Oracle ContractThis is a simple oracle contract that returns a hardcoded ETH/USD price. It can be updated by the owner to simulate live price changes.// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; contract Oracle { uint256 public price = 2000 * 1e18; // $2000 per ETH address public owner; constructor() { owner = msg.sender; } function setPrice(uint256 _price) external { require(msg.sender == owner, "Only owner can set price"); price = _price; } function getPrice() external view returns (uint256) { return price; } }Also, Check | PayPal Launches its U.S. Dollar Stablecoin PayPal USD (PYUSD)3. CDPVault.sol – Core CDP ContractThis contract manages ETH collateral, allows borrowing and repayment in USDC, and handles liquidation if the collateral ratio is violated.// SPDX-License-Identifier: MIT pragma solidity ^0.8.22; import "./Usdc.sol"; import "./Oracle.sol"; contract CDPVault { USDC public stablecoin; Oracle public oracle; uint256 public constant COLLATERAL_RATIO = 150; uint256 public constant PRECISION = 1e18; mapping(address => uint256) public collateralETH; mapping(address => uint256) public debt; constructor(address _stablecoin, address _oracle) { stablecoin = USDC(_stablecoin); oracle = Oracle(_oracle); } function depositCollateral() external payable { require(msg.value > 0, "Must deposit ETH"); collateralETH[msg.sender] += msg.value; } function borrow(uint256 amount) external { require(amount > 0, "Invalid borrow amount"); uint256 ethPrice = oracle.getPrice(); uint256 collateralValue = (collateralETH[msg.sender] * ethPrice) / PRECISION; uint256 maxBorrow = (collateralValue * 100) / COLLATERAL_RATIO; require(debt[msg.sender] + amount <= maxBorrow, "Exceeds borrow limit"); debt[msg.sender] += amount; stablecoin.mint(msg.sender, amount * 1e18); } function repay(uint256 amount) external { require(debt[msg.sender] >= amount, "Repaying more than owed"); uint256 scaledAmount = amount * 1e18; stablecoin.transferFrom(msg.sender, address(this), scaledAmount); stablecoin.burn(address(this), scaledAmount); debt[msg.sender] -= amount; } function withdraw(uint256 amount) external { require( amount > 0 && collateralETH[msg.sender] >= amount, "Invalid amount" ); uint256 ethPrice = oracle.getPrice(); uint256 newCollateral = collateralETH[msg.sender] - amount; uint256 newCollateralValue = (newCollateral * ethPrice) / PRECISION; require( debt[msg.sender] == 0 || (newCollateralValue * 100) / debt[msg.sender] >= COLLATERAL_RATIO, "Would become undercollateralized" ); collateralETH[msg.sender] = newCollateral; payable(msg.sender).transfer(amount); } function liquidate(address user) external { uint256 ethPrice = oracle.getPrice(); uint256 userCollateral = collateralETH[user]; uint256 userDebt = debt[user]; require(userDebt > 0, "No debt to liquidate"); uint256 collateralValue = (userCollateral * ethPrice) / PRECISION; uint256 requiredValue = (userDebt * COLLATERAL_RATIO) / 100; require(collateralValue < requiredValue, "Position is healthy"); uint256 scaledDebt = userDebt * 1e18; stablecoin.transferFrom(msg.sender, address(this), scaledDebt); stablecoin.burn(address(this), scaledDebt); collateralETH[user] = 0; debt[user] = 0; payable(msg.sender).transfer(userCollateral); } }DeployThis deployment script uses Hardhat to build up all required smart contracts for the CDP system. First, a fictitious USDC token with a 6-decimal precision and a 1,000,000 token initial supply is deployed. A straightforward Oracle contract with a hardcoded ETH price is then deployed. The primary CDPVault contract is then deployed utilising the USDC and Oracle addresses. In order to mint and burn tokens during borrow and repay activities, it lastly configures the CDPVault as the USDC token minter.const hre = require("hardhat"); async function main() { const [deployer] = await hre.ethers.getSigners(); console.log("Deploying contracts with:", deployer.address); // Deploy USDC with 6 decimals and 1,000,000 initial supply const USDC = await hre.ethers.getContractFactory("USDC"); const usdc = await USDC.deploy( "USD Test Coin", "USDC", 6, hre.ethers.parseUnits("1000000", 6) ); await usdc.waitForDeployment(); console.log("USDC deployed at:", usdc.target); // Deploy Oracle const Oracle = await hre.ethers.getContractFactory("Oracle"); const oracle = await Oracle.deploy(); await oracle.waitForDeployment(); console.log("Oracle deployed at:", oracle.target); // Deploy CDPVault const CDPVault = await hre.ethers.getContractFactory("CDPVault"); const vault = await CDPVault.deploy(usdc.target, oracle.target); await vault.waitForDeployment(); console.log("CDPVault deployed at:", vault.target); // Set vault as the minter const tx = await usdc.setMinter(vault.target); await tx.wait(); console.log("Vault set as minter on USDC"); } main().catch((error) => { console.error(error); process.exitCode = 1; });To deploy the contracts on the Sepolia test network, you can run the following command:npx hardhat run scripts/deploy.js --network sepoliaThe USDC token, Oracle, and CDPVault contracts will be deployed on Sepolia by the script when you execute this command. After that, the CDPVault will be designated as the USDC token minter. Following a successful deployment, the console will display the deployed contract addresses and the deployer's wallet address for your testing and engagement.Also, Discover | The Ultimate Guide to Stablecoin Development 2025 EditionConclusionThis post describes how to use Hardhat to create a basic decentralised stablecoin system. The implementation of a CDPVault contract, a simple price oracle, and a mock USDC token has resulted in a functional prototype that replicates the process of ETH deposits, stablecoin borrowings, and collateralised debt positions. A more reliable DeFi application can be built upon this base with well-defined deployment procedures and a testable configuration on the Sepolia network. If you are planning to build and launch a stablecoin using CDP, connect with our skilled blockchain developers to get started.

Technology: EXPRESS.JS , COSMOS IBC more Category: Blockchain Development & Web3 Solutions

Mudit Singh

30 Apr 2025

Developing a Peer-to-Peer Car Rental System on Blockchain (with Code) The world is shifting towards decentralized blockchain solutions, and peer-to-peer services are at the forefront of this transformation. One particularly exciting application is a decentralized peer-to-peer car rental system, where users can list, rent, and return vehicles — all without relying on traditional intermediaries — powered entirely by smart contracts. This dApp enables car owners and renters to connect directly, eliminating the need for centralized companies like Turo, Hertz, or Zipcar. Instead of placing trust in a third party, the system relies on blockchain-based smart contracts to manage:Listing cars for rentProcessing rental payments and security depositsStarting and ending rental agreementsRefunding deposits after car returnTracking user reputation and reviewsWhy Build a Car Rental System on Blockchain?Trustless Transactions — No middleman requiredTransparency — All terms and transactions are verifiable on-chainSecurity — Funds are held in escrow by smart contractsOwnership Proof — NFTs can represent cars and rental rightsGlobal Access — Anyone with a wallet can participateAlso, Read | Developing a Ride-Sharing App like Uber with BlockchainSystem OverviewOur decentralized car rental system includes:Smart Contracts for listing, renting, and returning carsWallet Integration for direct paymentsIPFS Support (optional) for storing car images and documentsReputation System using on-chain reviewsFlow Diagram:Car Owner → List Car → Set Price, Deposit, TermsRenter → Browse → Rent → Pay Rental Fee & DepositSmart Contract Holds Funds → Starts Rental TimerRenter Returns Car → Owner Confirms ReturnContract Releases Funds → Both Parties Leave ReviewsYou may also like | Blockchain Meets Mining Supply Chain for End-to-End TrackingSmart Contract: Core ImplementationHere's a basic version of the CarRental smart contract:solidity CopyEdit// SPDX-License-Identifier: MIT pragma solidity ^0.8.24; contract CarRental { struct Car { address payable owner; uint256 pricePerDay; uint256 securityDeposit; bool available; } struct Rental { address renter; uint256 startTime; uint256 endTime; uint256 totalPaid; bool active; } uint256 public carCount; mapping(uint256 => Car) public cars; mapping(uint256 => Rental) public rentals; event CarListed(uint256 indexed carId, address owner, uint256 pricePerDay, uint256 securityDeposit); event CarRented(uint256 indexed carId, address renter, uint256 startTime, uint256 endTime); event CarReturned(uint256 indexed carId, bool damaged); /// List a car function listCar(uint256 pricePerDay, uint256 securityDeposit) external { carCount++; cars[carCount] = Car( payable(msg.sender), pricePerDay, securityDeposit, true ); emit CarListed(carCount, msg.sender, pricePerDay, securityDeposit); } /// Rent a car function rentCar(uint256 carId, uint256 rentalDays) external payable { Car storage car = cars[carId]; require(car.available, "Car not available"); uint256 totalCost = (car.pricePerDay * rentalDays) + car.securityDeposit; require(msg.value >= totalCost, "Insufficient payment"); rentals[carId] = Rental( msg.sender, block.timestamp, block.timestamp + (rentalDays * 1 days), msg.value, true ); car.available = false; emit CarRented(carId, msg.sender, block.timestamp, block.timestamp + (rentalDays * 1 days)); } /// Return the car function returnCar(uint256 carId, bool damaged) external { Rental storage rental = rentals[carId]; Car storage car = cars[carId]; require(rental.active, "Rental not active"); require(rental.renter == msg.sender, "Not the renter"); rental.active = false; car.available = true; if (damaged) { // Owner keeps deposit if car is damaged car.owner.transfer(rental.totalPaid); } else { // Refund deposit to renter, rest to owner uint256 rentalFee = car.pricePerDay * ((rental.endTime - rental.startTime) / 1 days); car.owner.transfer(rentalFee); payable(rental.renter).transfer(rental.totalPaid - rentalFee); } emit CarReturned(carId, damaged); } } Also, Discover | Developing a Food Delivery App like UberEats with BlockchainConclusionThis peer-to-peer car rental system illustrates the power of decentralized applications to disrupt traditional industries. By using smart contracts, users can interact in a trustless, secure, and transparent way, with no need for centralized oversight. With continued development, features like NFT-based ownership, dispute resolution, dynamic pricing, and AI-driven reviews can make such dApps viable real-world alternatives to existing platforms. Blockchain isn't just a trend — it's the foundation of the next generation of digital services. If you have an inventive business idea and want to bring it to reality, leveraging decentralized technologies, connect with our skilled blockchain developers to get started.

Technology: ANGULAR , ReactJS more Category: Blockchain Development & Web3 Solutions

Yogesh Sahu

30 Apr 2025

Building a Blockchain-Based Freelance Payment System Freelance work is increasingly global, but traditional platforms still face issues like delayed payments, high fees, and trust concerns. A blockchain-based freelance system, built using blockchain development services, can eliminate middlemen, ensure fair payments through smart contracts, and offer transparent dispute resolution.What We're BuildingA decentralized freelance payment system on Ethereum (or any EVM-compatible chain) featuring:Escrow-based paymentsClient and freelancer ratingsDispute resolution via third-party votersFull transparency with on-chain historyContract ArchitectureFreelance Escrow – Handles escrow, job creation, approval, payment withdrawal, disputes, and ratings.Freelance Escrow ContractThis contract manages the core features of the system, such as creating freelance jobs, approving work, withdrawing payments, rating both parties, and handling disputes. Here's the contract code:// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; contract FreelanceEscrow { struct Job { address client; address freelancer; uint256 amount; bool isApproved; bool isWithdrawn; bool disputeOpened; address[] voters; uint8 votesForFreelancer; uint8 freelancerRating; uint8 clientRating; bool freelancerRated; bool clientRated; mapping(address => bool) hasVoted; } Job[] public jobs; event JobCreated(uint256 indexed jobId, address client, address freelancer, uint256 amount); event JobApproved(uint256 indexed jobId); event PaymentWithdrawn(uint256 indexed jobId); event FreelancerRated(uint256 indexed jobId, uint8 rating); event ClientRated(uint256 indexed jobId, uint8 rating); event DisputeOpened(uint256 indexed jobId); event DisputeVoted(uint256 indexed jobId, bool supportFreelancer); // Public method for creating freelance jobs function createFreelanceJob(address _freelancer) external payable { require(msg.value > 0, "Escrow must have funds"); uint256 jobId = jobs.length; Job storage newJob = jobs.push(); newJob.client = msg.sender; newJob.freelancer = _freelancer; newJob.amount = msg.value; newJob.isApproved = false; newJob.isWithdrawn = false; newJob.disputeOpened = false; newJob.voters = new address[](0) ; newJob.votesForFreelancer = 0; newJob.freelancerRating = 0; newJob.clientRating = 0; newJob.freelancerRated = false; newJob.clientRated = false; emit JobCreated(jobId, msg.sender, _freelancer, msg.value); } // Approve work function (public) function approveWork(uint256 jobId) external { Job storage job = jobs[jobId]; require(msg.sender == job.client, "Only client can approve"); require(!job.isApproved, "Already approved"); job.isApproved = true; emit JobApproved(jobId); } // Withdraw payment function (public) function withdrawPayment(uint256 jobId) external { Job storage job = jobs[jobId]; require(msg.sender == job.freelancer, "Only freelancer"); require(!job.isWithdrawn, "Already withdrawn"); require( job.isApproved || (job.disputeOpened && job.votesForFreelancer > job.voters.length / 2), "Not eligible for withdrawal" ); job.isWithdrawn = true; payable(job.freelancer).transfer(job.amount); emit PaymentWithdrawn(jobId); } // Rate freelancer (public) function rateFreelancer(uint256 jobId, uint8 _rating) external { Job storage job = jobs[jobId]; require(msg.sender == job.client, "Only client"); require(!job.freelancerRated, "Already rated"); require(_rating <= 5, "Rating out of range"); job.freelancerRating = _rating; job.freelancerRated = true; emit FreelancerRated(jobId, _rating); } // Rate client (public) function rateClient(uint256 jobId, uint8 _rating) external { Job storage job = jobs[jobId]; require(msg.sender == job.freelancer, "Only freelancer"); require(!job.clientRated, "Already rated"); require(_rating <= 5, "Rating out of range"); job.clientRating = _rating; job.clientRated = true; emit ClientRated(jobId, _rating); } // Open dispute (public) function openDispute(uint256 jobId, address[] calldata _voters) external { Job storage job = jobs[jobId]; require(msg.sender == job.client || msg.sender == job.freelancer, "Unauthorized"); require(!job.disputeOpened, "Already open"); require(_voters.length > 0, "Voters required"); job.disputeOpened = true; job.voters = _voters; emit DisputeOpened(jobId); } // Vote in dispute (public) function voteDispute(uint256 jobId, bool supportFreelancer) external { Job storage job = jobs[jobId]; require(job.disputeOpened, "No dispute active"); require(!job.hasVoted[msg.sender], "Already voted"); bool validVoter = false; for (uint i = 0; i < job.voters.length; i++) { if (job.voters[i] == msg.sender) { validVoter = true; break; } } require(validVoter, "Not an assigned voter"); job.hasVoted[msg.sender] = true; if (supportFreelancer) { job.votesForFreelancer++; } emit DisputeVoted(jobId, supportFreelancer); } // Get job details function getJob(uint256 jobId) external view returns ( address client, address freelancer, uint256 amount, bool isApproved, bool isWithdrawn, bool disputeOpened, uint8 votesForFreelancer, uint8 freelancerRating, uint8 clientRating, bool freelancerRated, bool clientRated ) { Job storage job = jobs[jobId]; return ( job.client, job.freelancer, job.amount, job.isApproved, job.isWithdrawn, job.disputeOpened, job.votesForFreelancer, job.freelancerRating, job.clientRating, job.freelancerRated, job.clientRated ); } }Key FeaturesEscrow System: Clients deposit funds into an escrow that's automated through smart contracts, allowing freelancers to withdraw only after approval or a resolved dispute.On-chain Ratings: Both the freelancer and client rate each other (1–5 stars), leaving immutable feedback for transparency.Dispute Voting: Third-party voters (assigned during the dispute) vote on the dispute's outcome. If the freelancer wins the majority vote, they can withdraw the funds even if the client hasn't approved the work.Job Tracking: All jobs created are indexed and can be referenced in the factory contract for easy tracking.Example Usage FlowJob Creation: The client callscreateFreelanceJob(freelancer) and deposits ETH.Freelancer Completes Work: The freelancer finishes the task.Client Approves Work: The client approves the work by callingapproveWork().Freelancer Withdraws Payment: If the work is approved or after a successful dispute vote, the freelancer callswithdrawPayment().Ratings: After the transaction, both parties rate each other usingrateFreelancer() andrateClient().Dispute Process: If the client doesn't approve the work, a dispute can be opened, and voters vote usingvoteDispute(). If the freelancer wins, they can withdraw the payment.Security ConsiderationsReentrancy Protection: Use ofnonReentrant modifiers to prevent reentrancy attacks during payment withdrawals.Identity Systems: Incorporate ENS or Decentralized IDs (DIDs) to enhance identity verification and trust.DAO Governance: Consider replacing the static voter selection system with DAO governance for more decentralized dispute resolution.ConclusionThis blockchain-based freelancer payment system empowers both freelancers and clients to interact directly, ensuring trustless, fair, and transparent transactions. With no platform fees, instant payouts, decentralized dispute resolution, and an on-chain reputation system, this solution is poised to redefine global freelance work, promoting fairness and reducing reliance on centralized platforms.Ready to build your own decentralized freelance platform?Get in touch with our blockchain experts to develop a secure, smart contract-powered payment system tailored to your needs. Contact us today.

Technology: EXPRESS.JS , ETHERSCAN more Category: Blockchain Development & Web3 Solutions

Ankit Mishra

30 Apr 2025

ERC-3643 RWA Tokenization | Create KYC-Compliant Permitted Tokens ERC-3643, also known as “permissioned tokens,” “RWA tokens,” or T-REX (Token for Regulated EXchanges), is a standard designed to tokenize real-world assets while ensuring compliance with regulatory requirements. This protocol enables the representation of traditional assets—such as debt instruments, real estate, and equity shares—on blockchain networks in accordance with financial regulations. Unlike conventional crypto tokens, ERC-3643 incorporates built-in compliance features that uphold legal obligations throughout the token's lifecycle. A key element of this standard is mandatory identity verification, requiring all token holders to complete Know Your Customer (KYC) and Anti-Money Laundering (AML) checks before participating in the ecosystem.For enterprises exploring secure and compliant tokenization solutions, collaborating with an experienced asset tokenization development company can streamline the process from design to deployment.ERC-3643 Smart Contract and RWA Tokenization | Technological ComponentsIdentity management integration using ONCHAINID technologyStorage of verified participant credentials on the chainRules for programmable compliance that guarantee each transaction is verifiedAutomated implementation of legal obligationsDespite these advanced compliance features that facilitate easier integration with wallets, exchanges, and other blockchain platforms, ERC-3643 remains fully compatible with the existing ERC-20 infrastructure. ERC-3643 is an excellent choice for institutional use and security token sales when adherence to the law is essential due to its mix of technological compatibility and legal compliance.This standard marks a significant breakthrough in the integration of blockchain technology with traditional financial institutions by providing digital assets with the programmability and legal certainty necessary for the tokenisation of physical assets.Also, Check | Create DeFi Index Fund with Custom ERC-4626 Tokenized VaultsBringing ERC-3643 to Life for Regulated Token Transfers with the T-REX ProtocolA useful use of the ERC-3643 Ethereum standard, the T-REX protocol was created by Tokeny Solutions to facilitate the compliance issues, transfer, and administration of security tokens. While ERC-3643 lays out the guidelines for token compliance, T-REX uses a collection of Solidity smart contracts to make these guidelines a reality. By combining identity registries and compliance checks, this system guarantees that all token-related activities adhere to legal standards. Based on T-REX's approach, ERC-3643 was officially adopted as an Ethereum standard in December 2023. It is now recognised as a reliable framework for compliant tokenisation by institutions and authorities around the world.Implementation of RWA Tokenization with ERC-3643:Token.sol filepragma solidity 0.8.17; import "@onchain-id/solidity/contracts/interface/IIdentity.sol"; import "./TokenStorage.sol"; import "../roles/AgentRoleUpgradeable.sol"; contract Token is AgentRoleUpgradeable, TokenStorage { modifier whenNotPaused() { require(!_tokenPaused, "Pausable: paused"); _; } modifier whenPaused() { require(_tokenPaused, "Pausable: not paused"); _; } function init( address _identityRegistry, address _compliance, string memory _name, string memory _symbol, uint8 _decimals, address _onchainID ) external initializer { require(owner() == address(0), "already initialized"); require(_identityRegistry != address(0) && _compliance != address(0), "invalid argument"); require(bytes(_name).length > 0 && bytes(_symbol).length > 0, "invalid argument"); require(_decimals <= 18, "invalid decimals"); __Ownable_init(); _tokenName = _name; _tokenSymbol = _symbol; _tokenDecimals = _decimals; _tokenOnchainID = _onchainID; _tokenPaused = true; setIdentityRegistry(_identityRegistry); setCompliance(_compliance); emit UpdatedTokenInformation(_tokenName, _tokenSymbol, _tokenDecimals, _TOKEN_VERSION, _tokenOnchainID); } function approve(address _spender, uint256 _amount) external override returns (bool) { _approve(msg.sender, _spender, _amount); return true; } function transfer(address _to, uint256 _amount) public override whenNotPaused returns (bool) { require(!_frozen[_to], "Wallet is frozen"); return _transfer(msg.sender, _to, _amount); } function transferFrom( address _from, address _to, uint256 _amount ) external override whenNotPaused returns (bool) { require(!_frozen[_to] && !_frozen[_from], "wallet is frozen"); _approve(_from, msg.sender, _allowances[_from][msg.sender] - _amount); _transfer(_from, _to, _amount); return true; } function setName(string calldata _name) external onlyOwner { require(bytes(_name).length > 0, "invalid argument"); _tokenName = _name; emit UpdatedTokenInformation(_tokenName, _tokenSymbol, _tokenDecimals, _TOKEN_VERSION, _tokenOnchainID); } function setSymbol(string calldata _symbol) external onlyOwner { require(bytes(_symbol).length > 0, "invalid argument"); _tokenSymbol = _symbol; emit UpdatedTokenInformation(_tokenName, _tokenSymbol, _tokenDecimals, _TOKEN_VERSION, _tokenOnchainID); } function pause() external onlyAgent whenNotPaused { _tokenPaused = true; emit Paused(msg.sender); } function unpause() external onlyAgent whenPaused { _tokenPaused = false; emit Unpaused(msg.sender); } function _approve( address owner, address spender, uint256 amount ) internal virtual { _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer(address sender, address recipient, uint256 amount) internal returns (bool) { _balances[sender] -= amount; _balances[recipient] += amount; emit Transfer(sender, recipient, amount); return true; } function name() public view override returns (string memory) { return _tokenName; } function symbol() public view override returns (string memory) { return _tokenSymbol; } function decimals() public view override returns (uint8) { return _tokenDecimals; } function totalSupply() public view override returns (uint256) { return _totalSupply; } function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } }With features like role-based access control, token information updating, and transfer pausing, this Solidity contract implements a token. To manage roles and keep track of token information, it extends AgentRoleUpgradeable and TokenStorage. Functions for transferring, authorizing, and managing allowances are included in the contract, along with provisions for frozen wallets and paused status. To change the token's name or symbol, only the owner can do it. Transfers can be paused or resumed by agents, and the contract tracks state changes by emitting events. Enhanced access control is integrated with ERC-20 capabilities.Also, Discover | ERC 4337 : Account Abstraction for Ethereum Smart Contract WalletsToken Storage file:pragma solidity 0.8.17; import "../compliance/modular/IModularCompliance.sol"; import "../registry/interface/IdentityRegistry.sol"; contract TokenStorage { mapping(address => uint256) internal _balances; mapping(address => mapping(address => uint256)) internal _allowances; uint256 internal _totalSupply; string internal _tokenName; string internal _tokenSymbol; uint8 internal _tokenDecimals; address internal _tokenOnchainID; string internal constant _TOKEN_VERSION = "4.1.3"; mapping(address => bool) internal _frozen; mapping(address => uint256) internal _frozenTokens; bool internal _tokenPaused = false; IIdentityRegistry internal _tokenIdentityRegistry; IModularCompliance internal _tokenCompliance; uint256[49] private __gap; }Token properties such as name, symbol, and decimals, as well as balances, allowances, and the total supply, are all stored in the Token Storage contract. In addition to tracking paused and suspended accounts, it connects with the identity registry and external compliance contracts. For upcoming upgrades, a gap array is also included in the contract.pragma solidity 0.8.17; import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "./Roles.sol"; contract AgentRoleUpgradeable is OwnableUpgradeable { using Roles for Roles.Role; Roles.Role private _agents; event AgentAdded(address indexed _agent); event AgentRemoved(address indexed _agent); modifier onlyAgent() { require(isAgent(msg.sender), "AgentRole: caller does not have the Agent role"); _; } function addAgent(address _agent) public onlyOwner { require(_agent != address(0), "invalid argument - zero address"); _agents.add(_agent); emit AgentAdded(_agent); } function removeAgent(address _agent) public onlyOwner { require(_agent != address(0), "invalid argument - zero address"); _agents.remove(_agent); emit AgentRemoved(_agent); } function isAgent(address _agent) public view returns (bool) { return _agents.has(_agent); } }Balances, allowances, the total supply, and token properties like name, symbol, and decimals are all stored in the Token Storage contract. It interfaces with identity registry and external compliance contracts, and it keeps track of stopped and suspended accounts. Additionally, a gap array for upcoming updates is included in the contract.Roles.sol Filepragma solidity 0.8.17; library Roles { struct Role { mapping(address => bool) bearer; } function add(Role storage role, address account) internal { require(!has(role, account), "Roles: account already has role"); role.bearer[account] = true; } function remove(Role storage role, address account) internal { require(has(role, account), "Roles: account does not have role"); role.bearer[account] = false; } function has(Role storage role, address account) internal view returns (bool) { require(account != address(0), "Roles: account is the zero address"); return role.bearer[account]; } }The Roles library provides a reusable structure to manage role-based access control in Solidity. It defines a Role struct that maps addresses to a boolean indicating role ownership. The library includes functions to add and remove roles, ensuring no duplicates or removals of non-existent roles, and a check function to verify if an address holds a role.You may also like | A Guide to Implementing NFT Royalties on ERC-721 & ERC-1155ConclusionMore than just a foundation for traditional financial assets, ERC 3643 has developed into much more. It establishes the framework for managing and digitising a variety of asset categories that were previously thought to be difficult or prohibitive to tokenise. ERC3643 stands out as a crucial solution in the developing field of asset tokenization, ensuring safe and legal ownership, access, transferability, and usage of digital assets, thanks to its integrated regulatory compliance measures and flexible, scalable design. In case you are looking to explore RWA tokenization, connect with our skilled blockchain developers.

Technology: ETHERSCAN , ETHERJS more Category: Blockchain Development & Web3 Solutions

Tushar Shrivastava

30 Apr 2025

how to build and launch a custom token (Rebase Logic) Understanding Rebase Tokens in EthereumA rebase token is created using cryptocurrency development services. It is a crypto token that does not have a set amount in each holder's wallet. Instead, they dynamically modify balances through a rebase process.Most cryptocurrencies (like Bitcoin, ETH, and USDC) have a fixed supply model.Meaning: If your wallet says 100 USDC, that's because you either received it via transfer or earned it via a transaction, and it stays there unless you manually do something.Rebase tokens are different.They automatically adjust wallet balances without explicit transfers!Rebase tokens vs. fixed supply tokensThe supply of many cryptocurrencies, including Bitcoin and conventional ERC-20 tokens like USDC and UNI, is fixed. These tokens may mint or burn tokens to modify the supply. Only explicit transfers between wallets can change wallet balances.Rebase tokens, on the other hand, have dynamic supplies and wallet balances that alternate automatically without the need for explicit transfers thanks to built-in rebase mechanisms. The balance of a wallet on Etherscan might therefore differ from the net of its transactions.Example: Fixed supplyReceiving a USDC transfer or engaging with a smart contract (such as a Uniswap transaction) that initiates a transfer are the only ways for a wallet with $100 USDC to increase its balance. This is simple to understand from a tax standpoint because every purchase and sale is explicitly documented in the transaction history.Example: Rebase tokenThe balance of a wallet should be 0 AMPL if it receives 100.02 AMPL at first, transfers 0.02 AMPL, and then transfers out 100 AMPL. However, because of the rebase mechanism, the balance might show 50 AMPL instead, which would indicate that the supply of tokens has increased since they were first received.Also, Check | How to Fetch Token Pricing with On-Chain Bonding CurvesDesigning a rebasing tokenSmart Contract Structure// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol"; import {IERC20Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol"; contract ElasticToken is IERC20, IERC20Errors { uint256 internal totalShares; mapping(address => uint256) internal shares; mapping(address => mapping(address => uint256)) public allowance; receive() external payable {} function mint(address to) external payable { require(to != address(0), "Invalid address"); uint256 newShares = totalShares == 0 ? msg.value : msg.value * totalShares / (address(this).balance - msg.value); require(newShares > 0, "Zero shares"); totalShares += newShares; shares[to] += newShares; emit Transfer(address(0), to, balanceOf(to)); } function burn(address from, uint256 amount) external { _spendAllowance(from, msg.sender, amount); uint256 shareAmount = _toShares(amount); shares[from] -= shareAmount; totalShares -= shareAmount; (bool sent, ) = from.call{value: amount}(""); require(sent, "ETH transfer failed"); emit Transfer(from, address(0), amount); } function transfer(address to, uint256 amount) external returns (bool) { transferFrom(msg.sender, to, amount); return true; } function transferFrom(address from, address to, uint256 amount) public returns (bool) { require(to != address(0), "Invalid address"); _spendAllowance(from, msg.sender, amount); uint256 shareAmount = _toShares(amount); shares[from] -= shareAmount; shares[to] += shareAmount; emit Transfer(from, to, amount); return true; } function approve(address spender, uint256 amount) external returns (bool) { allowance[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } function balanceOf(address account) public view returns (uint256) { return totalShares == 0 ? 0 : shares[account] * address(this).balance / totalShares; } function totalSupply() public view returns (uint256) { return address(this).balance; } function _toShares(uint256 amount) internal view returns (uint256) { return totalShares == 0 ? 0 : amount * totalShares / address(this).balance; } function _spendAllowance(address owner, address spender, uint256 amount) internal { if (owner != spender) { uint256 allowed = allowance[owner][spender]; require(allowed >= amount, "Allowance exceeded"); allowance[owner][spender] = allowed - amount; } } }Deployment Script (using Hardhat)// scripts/deploy.js const hre = require("hardhat"); async function main() { const ElasticToken = await hre.ethers.getContractFactory("ElasticToken"); const token = await ElasticToken.deploy(); await token.deployed(); console.log("ElasticToken deployed to:", token.address); } main().catch((error) => { console.error(error); process.exitCode = 1; });Deployment Steps:Install Hardhat:npm install --save-dev hardhat npx hardhatChoose "Create a basic sample project" (or an empty project if you prefer)Save the Solidity contract in contracts/ElasticToken.sol.Save the deploy script inside scripts/deploy.js.Run this to compile: npx hardhat compileDeploy on local/testnet:npx hardhat run scripts/deploy.js --network goerli (Replace goerli with sepolia, mainnet, or whichever network you want.)Verify on Etherscan (optional):npx hardhat verify --network goerli <your_contract_address>Also, Check | Creating a Token Curated Registry (TCR) on EthereumConclusionIn conclusion, rebase tokens represent a significant evolution in how token supply and wallet balances are managed within blockchain ecosystems like Ethereum. Unlike traditional fixed-supply tokens, rebase tokens automatically adjust user balances based on internal supply mechanisms without explicit transfers, creating new opportunities — and challenges — in DeFi and beyond. By leveraging smart contracts like the ElasticToken example, developers can create dynamic and responsive tokens that better reflect market conditions. With proper deployment and understanding, rebase tokens can drive innovative financial models while pushing the boundaries of what's possible in decentralized finance. If you are looking for defi development services, connect with our skilled blockchain developers to get started.

Technology: MYSQL , DJANGO more Category: Blockchain Development & Web3 Solutions

Rahul Maurya

29 Apr 2025

Hire the Best ReactJS Developer

Related Skills

Skills Blog Posts