# About ## **WEMIX3.0 Library** ### **Preface** WEMIX3.0 Library provides a transparent record keeping service and offers ease of access to such technical documentation compilation open to the community. The importance of accurate documentation, information management, and reliability of records can be found through the Joseon Dynasty. This historical reference is to illustrate the key ingredients of a successful records archive in the new Web3 world and the figurative comparison it has with how all WEMIX3.0 technical documentations will be securely stored and unreserved to the public. ### **The Joseon Dynasty, the 518-year legacy** The Joseon Dynasty is considered as the longest period of a single Dynasty in the world based on veritable records comprising 1,893 volumes of the annals. The propensity toward stability and peace on the Korean Peninsula during and even prior to the Joseon Dynasty is believed to have resulted from a variety of factors revolving around early ruling ideology structured specifically to maintain a long and healthy era. This unprecedented success can be traced back to the examination and analysis of its characteristics. #### **Governance: Royal decree based on decentralized council** Dynasty is essentially a ruling system with absolute power concentrated on the king or the monarch. The political system of Joseon Dynasty, however, was structured on dispersion of central power through the Three State Council(Chief State, Left State, and Right State) and the Six Ministries(Personnel, Taxation, Rites, Defense, Justice, and Works). The three State Councils were the highest organ of government under the Joseon Dynasty and were entrusted to deliberate over major decisions, advising the king, and conveying royal decisions to the Six Ministries. Through this political system, the king commanded absolute loyalty from his officials and subjects, while the officials were also expected to serve in advisory capacity to ruling the nation. This approach of decentralized governance by the Joseon Dynasty is the reason for it being the world’s longest and resolute dynasty in history. #### **Dissemination & Mass Adoption: Hangul, the Korean alphabet** The power of the bureaucrats in the decentralized governance model of the Joseon Dynasty must be well balanced in order that the officials as well as the nobles of the class status system were prevented from misdeeds associated with greed through monopolization of information. As a result, Hangul was created in 1443 by king Sejong the Great in an attempt to increase literacy of the lower class who were generally uneducated and illiterate of the Hanja(Classical Chinese) due to its difficulty. Hangul was invented so that the people could learn to read and write with ease to be given the same information as that of the higher class. The mass adoption of Hangul achieved a new level of fairness, freedom, and hope for the general public approximately 600 years prior to modern times. #### **Transparency & Immutability: The Veritable Records of the Joseon Dynasty** During the Joseon Dynasty, professional Chronicler recorded and maintained detailed accounts of national affairs, the king’s reign, and activities of the state throughout the dynasty. It is shown that a Chronicler had recorded an event that the king had requested to be omitted while also recording the king’s request itself in the Annals. As no one, including the king, was allowed to read the records, Chroniclers were ensured of their independence and neutrality without being affected by any sort of external pressure. The original drafts recorded by the Chroniclers and the veritas records compiled after the king’s death were copied and secretly stored in history archives throughout the country to prevent them from being lost in war or natural disasters. #### **One Vision: For the nation and its people** The reason behind the unorthodox institutions sought by the Joseon Dynasty which include decentralization, mass adoption of information, and transparency of historical records in a monarchical era was because the vision and purpose of the dynasty was centered around the development of the nation and the stability in the lives of its people. This is how the Joseon Dynasty became the world’s longest-lasting and peaceful single dynasty. ### **WEMIX3.0 and WEMIX3.0 Library** WEMIX3.0 is built to be a mega-ecosystem encompassing one public chain mainnet, one private chain, a stablecoin protocol, and three key platforms home to numerous DApps. To this end, the WEMIX3.0 Library functions as the archive where technical documentation and service philosophy of all services and platforms of the WEMIX3.0 mega-ecosystem are securely recorded and transparently disclosed to the public in order to facilitate the shared vision of WEMIX3.0 with NCPs and community members. The management and operational policies of these technical documentation and service philosophy are based on the general values of blockchain and are incorporated by the WEMIX3.0 Library which include decentralization, dissemination of information, transparency, security, and community-friendly accessibility. ### **Postface** WEMIX3.0 Library is designed to provide the community with the right tools and information required to understand the philosophy behind the mega-ecosystem and to enable them to participate in the growth of the community. Through WEMIX3.0 Library, community members and participants of the ecosystem can easily access what they need to create the world that they desire within the WEMIX3.0 mega-ecosystem. The only limitation is your own imagination. Welcome onboard WEMIX3.0, an experience-based, platform-driven & service-oriented mega-ecosystem. WEMIX Foundation ## ![Gyeongbokgung, the main royal palace of the Joseon Dynasty](/files/VuLnLAmbTFk2dzDJeXeR) ## WEMIX3.0 도서관 ### **시작하며** WEMIX3.0의 기술문서를 보관하는 도서관 서비스를 제공하며, 정확한 정보를 쉽게 제공하고 이를 기록해 놓는 것이 커뮤니티에 얼마나 중요한지에 대해 예전 동아시아의 조선왕조의 이야기를 예를 들며 서문을 대신합니다. ### **조선왕조 518년\*** 조선왕조는 중세시대인 13세기 이후 전세계 왕조 중 단일 왕조로서 가장 오래 유지되었던 왕조입니다. 여러 가지 평가가 있을 수 있겠지만 조선왕조가 이토록 세계적으로 전례를 찾아볼 수 없도록 길게 유지되었을 수 있었던 이유를 다음과 같은 특징에서 찾아볼 수 있습니다. #### 지배구조: 탈중앙화된 신권정치 왕조는 기본적으로 왕에게 모든 권력이 집중되는 구조입니다. 그러나, 조선왕조는 3명의 정승을 비롯한 신하들이 왕에게 의견을 개진하고 결정을 견제하며 나라와 백성을 위한 선정을 베풀도록 도왔습니다. 왕 또한 이러한 신하들의 견제를 당연한 것으로 여기고 의견에 귀기울였습니다. 이와 같이, 왕조이지만 왕에게 권력이 집중되지 않은 탈중앙화된 조선왕조의 지배구조는 몇번의 전쟁과 혼란에도 세계적으로 가장 오랫동안 왕조를 유지할 수 있었습니다. #### 정보의 대중화: 한글창제 임금 역시 지배구조에서 신하들과의 협의를 거친 조선왕조는 또한 신하들이자 신분제도상의 최상위에 위치한 양반들의 정보의 독점과 이에 따른 전횡을 방지하기 위한 노력을 많이 하였습니다. 이에 세종대왕은 조선의 모든 정보가 어려운 한자로 기록되어 교육의 기회를 갖지 못하는 백성이 공정하지 못한 환경에 놓인 것을 해결하기 위해 누구나 배우기 쉽고 말하는대로 그대로 표기할 수 있는 한글을 발명하였습니다. 한글을 세계에서 유래를 찾아보기 힘들 정도로 발명자가 밝혀져 있는 문자이며, 한글을 통해 지배계층에 의해 독점되던 정보와 지식이 일반 백성에게까지 전파되었습니다. #### 투명성: 조선왕조실록 조선왕조는 왕의 치세에 대해 사관(Chronicler)이 24시간 왕의 옆에서 기록했습니다. 심지어 방금 일어난 일을 기록하지 말아달라고 왕이 요청했다는 사실까지 기록할 정도로 조선왕조는 사관이 어떠한 외부적 압력에도 영향을 받지 않고 역사를 기록하게 했으며, 현재 왕은 자신의 역사 기록을 볼 수 없도록 하였습니다. 또한, 사관에 의해 기록된 원본인 사초와 왕의 사후에 편찬된 실록은 전쟁이나 재해 등으로 소실되는 것을 방지하기 위해 전국 각지에 사고를 만들어 복사본을 분산해서 보관하였고, 이 사고의 위치는 철저히 비밀이었습니다. #### 하나의 목적: 왕조를 중심으로 한 조선의 번영 이렇게 탈중앙과 정보의 대중화, 역사의 투명성 등 왕조시대에 용납하기 힘든 여러 제도들을 왕조가 받아들였던 이유는 단 한 가지, 왕조의 목적이 권력의 유지보다는 국가의 발전과 민생의 안정에 중심이 있었기 때문입니다. 때로는, 왕과 신하의 대립, 신하와 신하의 갈등, 정부와 백성의 충돌이 있었음에도 전례를 찾아볼 수 없는 500여년 동안의 단일 왕조인 조선왕조는 위에서 말한 하나의 비전과 철학을 가졌기 때문입니다. ### **WEMIX3.0과 위믹스 도서관** WEMIX3.0의 위믹스 커뮤니티의 번영을 위해 하나의 메인넷이자 퍼블릭체인, 하나의 프라이빗체인, 스테이블코인 프로토콜 및 3개의 플랫폼과 수많은 디앱이 공존하는 거대 생태계를 지향합니다. 이를 위해, 위믹스 도서관에서는 위믹스3.0 내의 주요 기술백서와 서비스 철학을 투명하게 공개하고 전파함으로, 재단으로 시작된 생태계가 수많은 NCP와 커뮤니티 구성원이 비전을 공감하고 함께 성장시키는데 도움이 되고자 합니다. 이러한 기술문서와 서비스 철학은 앞에서 말한 블록체인의 가치와 닮아있는 조선왕조의 지향 가치인 탈중앙화, 정보의 대중화와 투명성에 입각한 정확한 거래의 기록, 분산을 통한 보안을 포함하여 안정적인 기술, 커뮤니티 친화적인 운영과 정책을 포함합니다. ### **맺음말** WEMIX3.0 도서관은 커뮤니티 구성원이 생태계의 기술적 기반과 서비스 철학에 대해 정확한 정보를 파악하고, 쉽게 커뮤니티에 참여할 수 있도록 조성되었습니다. 이를 통해, WEMIX3.0 구성원들은 자신들이 만들고자 하는 세상을 쉽고 빠르며 정확하게 구현하게 도와주는 것에 그 목적이 있습니다. 유일한 한계는 당신 자신의 상상력입니다. 플랫폼 주도의 서비스 지향 거대 생태계인 WEMIX3.0에 오신 것을 환영합니다. 위믹스재단 ―――――――――――― \*조선왕조의 기간은 여러 기준에 따라 다를 수 있지만, 태조 이성계의 조선 건국 이후 고종의 대한제국 창제건원까지의 기간입니다. ## WEMIX Docs {% content-ref url="/spaces/Hf9f4FuSvei1yoMuW1wT" %} [WEMIX3.0 (ENG)](https://docs.wemix.com/en/) {% endcontent-ref %} {% content-ref url="/spaces/iXnTk8WgxaTaNidAuUYQ" %} [WEMIX3.0 (KOR)](https://docs.wemix.com/ko/) {% endcontent-ref %} ## WEMIX Stake {% content-ref url="/spaces/9Bl5EtEX8OIJgOa9aUHY" %} [Broken mention](broken://spaces/9Bl5EtEX8OIJgOa9aUHY) {% endcontent-ref %} {% content-ref url="/spaces/tPeeTJPHq2GYh5crHwN4" %} [Broken mention](broken://spaces/tPeeTJPHq2GYh5crHwN4) {% endcontent-ref %} ## NILE {% content-ref url="/spaces/qlGy1XJXC3snSpxBiv12" %} [NILE (ENG)](https://docs.wemix.com/nile-en/) {% endcontent-ref %} # Introduction ## WEMIX3.0 Summary WEMADE looks at the world in a slightly different light. As times change, we look the market and analyze it, and create a plan that can be put into action. And then, actually doing it and producing results, ultimately leading to other followers following WEMADE's path. Throughout the WEMIX1.0 & 2.0 era, our efforts to create a balanced ecosystem have enabled us to gain extensive knowledge, data and experience. And these are all the more important things that WEMADE is once again playing a role in transforming the industry and market. WEMIX3.0 is a true blockchain ecosystem designed to support the upcoming dApp, games, DAO, DeFi, NFT, and more. * EVM-compatible Public Chain * Stake-based Proof of Authority(SPoA) Consensus * 40 Highly Qualified Node Council Partners(Authorities) * Max 4,000 TPS Throughput * PMR(Permanent Minting Reward): 0.5 WEMIX per Block ## WEMIX3.0 Ecosystem The WEMIX3.0 Mainnet is based on Ethereum Virtual Machine (EVM) in the Stake-based Proof of Authority (SPoA) consensus algorithm. The new Mainnet provides the best security based on decentralized On-Chain Governance through 40 Node Council Partners (NCPs), while ensuring fast TPS at the same time. WEMIX$, with USDC as collateral, is an important good in the dApp ecosystem and serves to relieve the unpredictable price volatility of tokens and the resulting anxiety. WEMIX$ provides currency stability, which makes various dApps more stable in the ecosystem. By relieving the anxiety of the price volatility, WEMIX3.0 takes the ideal form of an open platform. At the heart of WEMIX3.0, there are three important services. We support WEMIX PLAY(a blockchain gaming platform), NILE(a DAO service based on the Neith protocol), and decentralized financial services. ## Indemnification Provision WEMIX3.0 blockchain is forked from Ethereum and refers to various Ethereum open source project technologies. The executed smart contract is implemented in Ethereum-based solidity language, and has a grammar similar to JavaScript as a Turing completeness form of computer language. Therefore, it is possible to program with a high degree of freedom without restrictions on implementation. The technology stack of WEMIX3.0 blockchain was developed using traditional Ethereum and supports EVM and library equivalent to Ethereum. WEMIX's improvement proposal fully accommodated the Ethereum improvement proposal (EIP) according to the configuration of the WEMIX ecosystem, and was adopted through some migrations. This makes it easier for members of the WEMIX3.0 ecosystem to participate in the WEMIX3.0 blockchain by forming an Ethereum-like ecosystem. Claims, contents, algorithms, roadmaps, etc. presented in this document are the result of this project effort. As a result, the person using the Software is deemed to have been bound and agreed to comply with all licenses applied thereto. # Blockchain Basics This section covers the concept of blockchain. * [What is Blockchain?](/en/introduction/blockchain-basics/what-is-blockchain) * [Consensus Algorithm](/en/introduction/blockchain-basics/consensus-algorithm) * [Transactions](/en/introduction/blockchain-basics/transactions) * [Gas](/en/introduction/blockchain-basics/gas) * [Account](/en/introduction/blockchain-basics/account) ## Glossary
# What is Blockchain? ## What is Blockchain? Blockchain is a distributed ledgers that can mathematically guarantee the consistency of data without a third party and cannot be forged or altered. It consists of distributed database technology, and makes decisions based on consensus algorithms using multiple participant votes. In addition, blocks composed of hash values are chained together, making it almost impossible to forge or falsify data. {% hint style="success" %} #### Basic Mechanism for Blockchain Transaction logging → Agreement(Block creation) → Chain connection with previous blocks → Ledger sharing {% endhint %} ## Key features of a Blockchain ### Decentralization * As a basic characteristic of blockchain, there is no centralized group and there is no 'third-party trust agency'. * Blockchain does not have a central administrator because it stores and attests data by many participants. * Transactions between individuals are possible through an electronic contract called 'Smart Contract' instead of a central administrator. ### Expandability * Opened sources allow any network participant to build, connect, or expand. * It is easy to expand between systems that require data sharing through the network, and you can also consider expanding to existing systems through APIs. ### Transparency * All transaction records linked to the blockchain are publicly accessible. * All transactions bring out into the open and It is possible to reduce security, supervision, and regulatory costs. ### Integrity * Once the data is embedded in a block and connected to a chain, it is virtually impossible to change the data. * This is because the blocks connected to the blockchain have a specific relationship with the previous block cryptographically, so you have to change all the blocks before the block you want to change. ## Key elements of a Blockchain ### Distributed ledger technology A distributed ledger is a database in which all the transactions that occurs in a blockchain is shared and stored. In the existing database, data could be registered, modified, and deleted, but once recorded transactions cannot be deleted in the blockchain. ### Smart Contracts Smart Contract is a technology that allows contracts to be made only by code without a third party agency. In the existing Bitcoin, it only operated with UTXO (Unspent Transaction Outputs), so it was only possible to make simple transactions, but it was not possible to make a contract. However, with the advent of smart contracts, the blockchain ecosystem could be expanded as various codes were created based on contracts as well as transactions. ### PKI Public Key Infrastructure (PKI) is usually considered a high-level identity authentication system. However, the centralized nature of the Certificate Authority often leads to problems with data ownership and reliability. As a result, many people have no choice but to trust the certification authority. No certification authority exists in the blockchain. The private key is kept by the user and the public key is stored in the blockchain to sign with the private key owned by the user when trading, and the blockchain determines whether the signature is valid. # Consensus Algorithm ## Consensus Algorithm Type Consensus algorithms are algorithms for participants to make unified decisions through decision-making. In the blockchain, consensus algorithms are also called consensus models, consensus methods, consensus mechanisms, and consensus protocols, and there is no central agency to mediate decision-making. This stems from the conviction that blockchain data will not be forged or altered because all participants have the same data at the same time. If someone else malicious attempts to falsify the data, you have to change the information about the previous block at a huge price. Consensus algorithms provide algorithms that allow multiple nodes to mutually validate data and generate correct blocks based on consensus. ### PoW (Proof of Work) PoW (Proof of Work) is a representative consensus algorithm used in Bitcoin as a proof of work method. In order for the miner to be rewarded, the block must be created through mining. Block generation is judged based on hash power, and hash power is a criterion for determining how much computing power can solve problems in a short time. Block creation obtains permission to create blocks by nodes that provide the highest hash power. ### PoS (Proof of Stake) PoS (Proof of Stake) is a proof-of-equity approach that allows nodes with large stakes to create blocks. Authorization to create blocks in proportion to equity, not PoW's work. In the case of PoW, compensation is paid at the time the block is created, while PoS is compensated with interest on the equity. The proof-of-equity scheme also penalizes the creation of incorrect blocks to prevent malicious intentional block generation. Anyone can participate in the blockchain network, as long as they have a coin equivalent to their stake, so that more nodes can participate in the consensus process in a decentralized environment. ### DPoS (Delegated Proof of Stake) DPoS (Delegated Proof of Stake) is a delegated equity demonstration method in which nodes with stakes determine the block creator through voting. In other words, all nodes do not have block creation rights, but they elect a parent node through a vote to delegate authority. It has fast performance and scalability because a small number of agreed parent nodes create blocks. # Transactions ## What is Transactions? In a blockchain, if the block is an account book, a transaction can be viewed as a transaction history recorded in the account book. Transactions are records of all transactions that occur on the blockchain. Transactions include transaction times, transmission and reception addresses, transaction assets, and fee information. ## Principles of Transactions When a transaction occurs, the transaction does not occur immediately. Blockchain requires verifier approval.
Suppose Bob sends 50 WEMIX (including fees) to Alice. Bob sends a transaction to Alice stating that he will send 50 WEMIX. Verify that Bob's address has quantities that can be transferred. If there is no transferable quantity, the transaction fails, but if there is a transferable quantity, the block constructor waits until the block is created. If the transaction sent by Bob was successfully recorded when the block was created, perform that transaction. Out of 100 WEMIX at Bob's address, 50 WEMIX will be sent to Alice's wallet address. # Gas ## What is Gas? 'Gas' is a unit of measurement for performing transactions or executing smart contracts in a blockchain network. Every action performed in a blockchain network costs gas. The gas cost depends on the complexity of the contract and the speed at which it is carried out. If you want to perform a transaction quickly, you can pay more gas than the base gas cost, and if you like to do it slowly, you can pay only the base gas cost. Gas costs are important because transactions submitted to the network help to pay appropriate fees. By requiring a transaction to pay for each action it performs (or by allowing a contract to be performed), the network performs many intensive tasks that are of no value to anyone, so that it does not get bogged down. ## Gwei The unit of gas cost is Gwei. It is calculated as 1 WEMIX = 1 billion Gwei. When a transaction occurs, the higher gas cost, the first recorded in the block, and the block creator will receive a fee as a reward. In a blockchain, the minimum unit is calculated as wei, 1 WEMIX = 10^18wei. Since wei has many digits, it is expressed in Gwei units.

Ethereum Basic Gas Fee

WEMIX Gas Fee Setting

## Base Fee Base Fee is the minimum amount to be paid as a basic fee. These costs are not fixed, and if there were a lot of transactions in the previous block, the minimum payment would be higher, and if there were less transactions, the cost would be lower. Base Fee was previously paid as compensation to the block creator, but has been incinerated after EIP-1559 reflection. ## Gas Limit Limits are set to limit gas costs. If the gas cost is insufficient to perform the transaction, the transaction will fail. Therefore, it is desirable to pay an appropriate amount of gas cost. If the gas cost exceeds the limit, the excess fee after the block creation will be returned. # Account WEMIX3.0 blockchain has External Owned Accounts (EOA) and Contact Accounts (CA). ## EOA EOA is simply a user account. A private key is generated through a wallet, and a public key is generated through a private key using the ECDSA algorithm. The EOA is authorized by the private key that the user has. ## CA CA is authorized by the contract code. Therefore, the CA does not have a private key. An electronic signature is required to generate a transaction and is signed with a private key. EOA has a private key, so it can generate transactions, but CA cannot create transactions on its own. The CA can only perform internal transactions at the request of another account. # Design This chapter contains important technical instructions to the WEMIX3.0 Blockchain. * [Architecture](/en/design/architecture) * [Consensus](/en/design/consensus) * [Governance](/en/design/governance) * [Minting](/en/design/minting) * [EIP1559](/en/design/eip1559) * [Fee Delegation](/en/design/fee-delegation) * [Roadmap](/en/design/roadmap) # Architecture ## WEMIX3.0 Client Network WEMIX Blockchain Client is an implementation of WEMIX3.0 that keeps network data safe and accurate by validating every transaction in each block. In Phase 1, WEMIX3.0 was created by forking Go-ethereum Version 1.10.16 based on the Go language, and applied the London Hard Fork. In Phase 2, WEMIX3.0 is reflected up to Version 1.10.18 and the code will continue to be updated. ![WEMIX3.0 Client Architecture Stack](https://lh5.googleusercontent.com/b2N2tBXyib72Kk9VSzaPvZ_-GYcbFP6zwGTvtNUhZyXhdENcb6tolBl06vwqPd1hzsVRYxUz45V-YiEcQngmsmWrFxB1Zq9WbFHauS_mLlowwTQTfDqUuqA9KOh1r-2ZYPjqBQ) WEMIX3.0 Client has a layering system as shown in the figure above and achieved high-performance real-time performance by modifying Governance, Consensus, and Network Protocol elements in go-Ethereum. ## WEMIX3.0 Network Structure The WEMIX blockchain network consists of three types of logical networks: BP, BN, and EN. These networks make up the Block Producer Network (BPN), Bridge Node Network (BNN), and End Node Network (ENN), respectively. The figure below shows the overall topology of the WEMIX mainnet. An End Node Network (ENN) can be viewed as a perimeter network directly connected to a Bridge Node Network (BNN). ![WEMIX3.0 Network Structure](https://lh6.googleusercontent.com/3dLIKYHhaiGGAU5vCdzaG7rvbbclt8QigVpVMA79YZW-il4DyieDTPxcb7GC1De7ak1Ox6l0kYDIDeeOhx1hUwAuQYr5p_Ba_1oolsMtox80F4kjHQGFi1xCA9FfIBmQReNecA) ### Block Producer Network(BPN) Since BPN applies RAFT on the network, each BP must strictly meet the hardware and network resource requirements to perform the RAFT consensus mechanism with adequate performance. To support high-performance real-time service, BP's technical operations are all handled by 40 reliable NCPs. ### Bridge Node Network(BNN) The BNN network primarily has the function of physically protecting the BPN network from direct external attacks. Its primary function is to verify the valid transaction propagated from the ENN and send it to the consensus node. Conversely, it is to confirm the block reproduced from the BPN and propagate it to the ENN. Also, some of the Bridge Nodes that exist in BNN provide the functions of Boot Nodes. All new nodes except BP nodes must download all block data generated so far from neighboring nodes connected to the P2P network in order to participate in the blockchain network. Boot Node is a service node that is always online and provides a Bootstrapping service that connects these new nodes participating in the network to the P2P network by unconditionally performing P2P Hand Shaking. WEMIX conducts the corresponding operation of the network. ### End Node Network(ENN) The outermost subnetwork, ENN, is an endpoint of the WEMIX network and consists of blockchain End Nodes that directly handle user services. Anyone can install and operate blockchain nodes. # Consensus A consensus mechanism(algorithm) is a method of reaching consensus among trustless parties. Blockchain technology is used to determine whether a block is valid. A blockchain network's performance depends on the chosen consensus mechanism's performance and significantly impacts the usability of blockchain applications. This document will look at how WEMIX implemented a high-performance consensus process. ## RAFT(Reliable And Fault Tolerant) Algorithm RAFT is a consensus method that ensures consistency of datastores on all nodes in the cluster by selected leader. Nodes participating in RAFT are either a Leader or a Follower; anyone can become a Candidate during a leader selection. A Leader must create and share data that needs to be synchronized with followers. A Leader announces the leader's existence by periodically sending a heartbeat message to all followers. Each follower randomly selects a timeout value for the leader's heartbeat, and if a heartbeat receives during the timeout period, the timeout resets again. On the other hand, if they do not receive a heartbeat during the timeout, the follower changes the status to a candidate and participates in the leader selection. Conflicts occur if multiple nodes simultaneously participate in a leader selection, so the timeout is determined according to random backoff logic. ## WEMIX3.0 Consensus Mechanism ### SPoA(Stake base Proof of Authority) The WEMIX Blockchain is a public blockchain that aims for high-performance real-time service, and block generation is possible only by authorized members in advance. Therefore, the basic consensus algorithm follows PoA. However, WEMIX forces to stake more than a specific amount to give a physical penalty for the malfunction of the elected authority on-chain. This WEMIX blockchain consensus method is defined as SPoA. ### Authority Authority participating in the consensus algorithm of the WEMIX Blockchain implies a consortium that performs the same role as the miner of the consensus mechanism PoW, such as Bitcoin/Ethereum. WEMIX Blockchain, the process of being included in or deleted from the Authority, is determined by voting the existing authority members. 1. Clear identity 2. Legally effective contract with WEMIX Foundation offline 3. Disclosure of basic personal information 4. Staked WEMIX to the system registry contract After staking is confirmed, any of the existing authority members propose a member add proposal to the governance contract. If more than 50% of the current authority members approve, they will be registered as a new Authority members. When the Authority receives the transactions created by users, it verifies the transaction details and temporarily stores the transactions that have passed the verification in the Mempool. When an Authority member is elected as a miner, it creates a block header including hash information of the previous block. This process is done automatically by software, and there is no need for the authority member to monitor the network status continuously. However, the authority member should be responsible for managing the firewall and private key of the account so that the computer generating the block is not used maliciously. Voting, which can be processed in the On-chain Governance contract, is currently supported in the form of dApp by voting for or against and will support various votes in the future. In Phase 1, voting weight is proportional to the amount of staked WEMIX and in Phase 2, the same voting weight is applied regardless of the amount of staked WEMIX. If malicious behavior is detected, the party can be forcibly disqualified from the Authority's voting, and the staked WEMIX is confiscated and may not receive block generation compensation. The reason for the staking and reward system is to create a justification for all participating authority members to operate under the agreed protocol and to maintain the soundness of the WEMIX blockchain network autonomously. ### Miner Selection Taking Bitcoin's PoW as an example, a miner that generates a block header hash that satisfies the difficulty calculated by the protocol can generate and propagate blocks. Since there is no independent authority for block creation, blocks are created by mutual competition. For this reason, resources are inevitably wasted for block generation competition. Work that satisfies the difficulty condition must be proven, so the block generation time is given a physical constraint (BTC 10 min avg. ETH/15 sec). As a result, PoW has a scalability trilemma, and the introduction of PoS or sharding has been proposed and researched as a realistic solution to solve this problem. However, so far, no public blockchain has operated as PoS in a fully distributed manner. The WEMIX Blockchain determined that providing the desired service in the public domain was impossible using methods such as PoW or PoS. Initially, consensus such as DPoS, PoA, and PBFT was considered methods, but the WEMIX Blockchain devised SPoA. This new Consortium consensus mechanism borrowed the advantages of DPoS and PoA as the most suitable consensus algorithm. SPoA is introducing the concept of staking to prevent inappropriate actions of the authority members who have formed the Authority and participated through transparent identity information and legal contracts. The WEMIX Blockchain uses etcd, the implementation of RAFT as a miner selection algorithm to select a miner who creates blocks. Etcd is an open-source distributed key-value repository used to store and manage sensitive information needed by distributed systems. Miner stores lockable tokens in the etcd distributed system and generates blocks. The reason for not using efficient miner selection, such as Round Robin, is to prevent the branching of consensus node networks in distributed systems. Etcd is an efficient way to provide immediate finality of many (40+) authorities with clear responsibilities and authority. ### Reward Distribution Existing consensus algorithms often concentrate block rewards and transaction fees within the block producer, the entity responsible for block creation. This presents a challenge in non-competitive systems like Delegated Proof-of-Stake (DPoS) and Proof-of-Authority (PoA), where fair distribution of block creation authority is paramount. Frequent leader changes to achieve equal opportunity can hinder performance due to increased communication overhead for Block Producers (BPs) processing transactions. To address these challenges, WEMIX3.0 introduces a Stake-based Proof-of-Authority (SPoA) consensus mechanism. This mechanism distributes rewards proportionally to the amount of WEMIX staked by each authority member, regardless of who creates the block. By doing so, it incentivizes continuous participation from all BPs while maintaining network security. Block producers must include transparent reward distribution details within the block header. Any violation of the predetermined rules, documented within the governance contract, will prevent other authorities from propagating the block. To achieve fair and sustainable reward distribution, WEMIX3.0 employs a dual structure for tokenomics, focusing on both block rewards and performance shares. Initially, rewards are distributed through block minting, ensuring that all participating members receive a portion of the block rewards. Over time, the system will transition towards an increasing allocation of performance shares tied directly to transaction fees. This shift is guided by a block minting halving mechanism that gradually reduces the minting rate until the maximum supply of 590 million WEMIX tokens is reached, at which point block minting will cease entirely.
Number of halving0123⋯16
Minting10.50.250.125⋯0.000015
Transaction feesαααα⋯α
Block reward1+α0.5+α0.25+α0.125+α⋯0.000015+α
As block minting rewards decrease, the reduction will be offset by an increasing share of transaction fees allocated as performance shares. This strategic shift ensures a balanced and fair distribution of rewards among all participants, promoting long-term network growth and sustainability. The meticulously crafted dual reward structure serves to fulfill WEMIX3.0's aspirations of becoming a leading commercial entity while offering a rational and sustainable reward system. WEMIX3.0 may implement a policy to burn part or all of transaction fees. All accounts that receive rewards (one per member) are registered by voting, except for the governance coin base account, which distributes the first system contracts to the governance contract. The authority member generating the block updates the balance state of the accounts, and the calculation result is reflected in the root hash value of Patricia Trie.
### Block Generation The governance contract determines the interval between block creation of the WEMIX Blockchain. BP has the logic of generating blocks at a set time (1 sec. of the initial set value) to ensure activity and block finality, regardless of transactions in the mempool. The block creation interval is the value of a variable that can be changed by permission voting. ### Block Verification When a block generated by a miner is propagated to a network through p2p, each full node (including an authority member) receiving the block must self-verify and determine the validity. Authority nodes verify whether the block is generated by a member selected as the miner, the reward is customarily distributed, and transaction details are reflected in the state of the entire system. After the verification, the authority nodes spread the blocks to the neighboring nodes. The non-authority full node that receives this propagation checks whether the signature of the member included in the header is correct and verifies the transaction details. When it is determined that the transaction recorded in the block is generated according to the rule, it stores the block on the local disk and propagates it to neighboring nodes. When verifying the propagated block, there are two things that all full nodes must verify first before proceeding with the above process: Miner\_Limit and Max\_Consecutive\_Blocks. Miner\_Limit is defined as follows. When a specific member is determined as a Miner in RAFT, an epoch that can create a block is given, and the purpose of this epoch is to prevent it from being given continuously. All blocks are valid only when the following Miner\_Limit is satisfied. Miner\_Limit = floor(SIGNER\_COUNT / 2) + 1 (Number of consecutive epochs out of which a miner may only occupy one) Max\_Consecutive\_Blocks is the maximum number of consecutive blocks the same Miner can create in an epoch. This value is a variable introduced to limit the height of a diverged block when a hacker attacks the network. In WEMIX3.0, Max\_Consecutive\_Blocks is 1. The above two values are a method for ensuring block finality and are designed to minimize the damage a malicious authority member can cause to the network. # Governance ## DAO(Decentralized Autonomous Organization) ### On-Chain Governance #### **Staking** WEMIX Staking is one of the prerequisites to becoming an authority member. The Staking method is possible by sending WEMIX while calling a predefined function to the governance contract known at the system level. Staking can only be done through Governance dApp, and the minimum amount of Staking can be changed by Voting. Voting power has the same weight regardless of the amount of locked WEMIX Staking. The result of Voting determines whether the WEMIX Staking is locked or unlocked. Once locked, WEMIX can be unlocked and retrieved by Voting after the default locking period has passed. If you relinquish your authority as an Authority before the locking period ends, or if you forfeit your authority due to the detection of malicious acts, your locked WEMIX will be forfeited to the Eco Fund. In Phase 1, all participating authorities had the minimum/maximum of 1,500,000 WEMIX, and all authorities have the same voting power. In Phase 2, the Staking minimum remains at 1,500,000 WEMIX, but the Staking maximum constraint is removed. In other words, NCPs can increase the Reward with additional WEMIX staking. #### **Voting** The WEMIX Blockchain(governance contract) stores system variables that can be changed by voting and have functions related to the participation, withdrawal, and replacement of authority members. In Phase 1, each Authority had Voting Power in proportion to the amount of Staking, and in Phase 2, all Authority have the same Voting Power regardless the Staking amount. Each voting will be passed if it win more than 50% of the votes in favor of the total Staking WEMIX during the Voting Duration(1-7 days). Only the Authority member can apply for the following voting. Voting duration can be determined within the minimum/maximum value range at the time of application and is designated as the minimum value when not specified. Voting starts and ends when a member votes for the first time in the application list and runs for the maximum voting duration. Even within the voting duration, if more than 50% of opinions are raised, voting ends, and follow-up work is carried out. Only one vote is conducted at a time; As a result, if voting is already underway, new voting cannot be initiated. The Voting types supported by the current version are as follows. Voting results are reflected based on block number, and voting results completed in block number `n` are valid from block number `n+1`. * Authority member(add): When the voting for adding an authority member passes by a majority vote, the staking amount of the member is locked and included in the authority member. * Authority member(withdrawal): Voting for processing the authority member's withdrawal (penalty), unlocking only the specified amount when applying, and sending the rest to the Eco Fund. * Authority member replacement(address change): When passing through voting to replace an existing authority member or change node information, if it is the same address, change the node information; if it is a different address, lock the new member's staking amount, and unlock the existing member's staking amount.\ However, if you change your own node information (including voting address) in your staking account, the corresponding information will be changed immediately without voting. * Governance Contract Address(change): Change the address when passing through voting to upgrade the existing Governance Contract. * Voting Duration(Minimum): The default is one day for voting to change the minimum voting period value. When passing, the minimum voting period is changed. * Voting Duration(Maximum): The default value is seven days for voting to change the maximum voting period value. When passing, the maximum voting period value is changed. * Authority member staking(Minimum value): Change the minimum staking WEMIX quantity value when passing through voting, which changes the minimum number of staking WEMIX quantity when participating as a member. * Authority member staking(Maximum value): Change the maximum staking WEMIX quantity value when passing through voting, which changes the maximum number of staking WEMIX quantity when participating as a member. * Block generation time: The default is 1 second for voting to process changes to the block creation time. When passing, the block creation time is changed. * Block reward distribution method: Voting to determine the transaction fee and the distribution rate of the newly created WEMIX, the default is 50% block producer, 0% staking compensation, 25% ecosystem, and 25% maintenance. The distribution rate, ecosystem, and maintenance distribution address are changed when passing. * MaxPriorityFeePerGas: Voting to handle changes in MaxPriorityFeePerGas. Once passed, the MaxPriorityFeePerGas will change. * Gas Limit & baseFee: Voting to handle changes in Gas Limit, range of baseFee and the increase rate of baseFee. {% hint style="info" %} If you delete the Authority member and then proceed with adding the same node again, you must delete the {data\_directory}/etcd directory and restart gwemix. {% endhint %} ### **Off-Chain Governance** If the foundation needs a hard fork, such as a "change of protocol", and explicit agreement of the council is required, the NCP agreement process is carried out using an Off-Chain service such as . Although the service is Off-Chain governance, the foundation can change the blockchain protocol based on the agreement of the explicit council because it receives more than half of the council's signature and performs voting. # Minting This is the description of Permanent Minting Reward (PMR). WEMIX, the native coin of the WEMIX mega-ecosystem, serves as the primary medium of exchange and payment within the WEMIX3.0 mainnet. With the introduction of the 'Brioche' hard fork, WEMIX tokenomics have undergone significant transformations, creating a sustainable and value-driven ecosystem. The hard fork permanently reduced and capped the maximum supply at 590 million WEMIX to preserve the token’s value and stability. The 'block minting halving' mechanism, introduced by the Brioche hard fork, is designed to gradually reduce the minting rate of WEMIX per block called 'Permanent Minting Reward (PMR)’ over time. Initially, WEMIX was minted at a rate of 1 WEMIX per block, amounting to 86,400 WEMIX per day or 31,536,000 WEMIX per year. The first halving reduced the annual minting amount to about 15 million WEMIX. This systematic reduction continues in 63,115,200-block cycles, progressively decreasing the number of tokens minted and fostering a more stable and advanced tokenomic structure. In addition to the reduced maximum supply and the new minting mechanism, the allocation of WEMIX has been updated to support the ecosystem's growth and development. The foundation's holdings are now categorized for various essential functions, with a significant portion of the remaining tokens burned. This strategic move effectively manages the token supply, removes the perception of a dominance structure, and fosters a more inclusive ecosystem, promoting greater participation and ownership. WEMIX is based on the ERC-20 standard (Ethereum Request for Comment-20), ensuring transferability and compatibility via bridging to other EVM chains. This foundational technology underpins the robust and versatile nature of the WEMIX ecosystem. # EIP1559 This section describes the application of the EIP1559 transaction pricing mechanism in WEMIX3.0. Ethereum historically priced transaction fees using a simple auction mechanism, where users send transactions with bids("gas prices") and miners choose transactions with the highest offers to generate the block. Although this mechanism may work in some systems, such as Bitcoin or Ethereum, where limited resources are acquired only through auctions, this leads to several sources of inefficiency, such as a mismatch between the volatility of transaction fee levels and the social cost of transactions and needless delays for users. EIP1559 is a dynamic transaction pricing mechanism applied in Ethereum London Hard-fork. This mechanism resolves network congestion algorithmically by burning a part of the block's transaction fee and adjusting the maximum gas usage of a block up and down by a 1/1024 scale. WEMIX3.0 uses SPoA, a consensus algorithm capable of high-capacity, high-speed processing. It can support up to 3.5 times the block size of Ethereum(default block gas limit: 105,000,000) and 1/12 times the block generation time of Ethereum(default time: 1 second). In a way, unlike Ethereum, it may be a reasonable option for WEMIX3.0 to use a fixed gas price policy determined by the Governance. However, fixing the gas price in the policy causes a problem. It may also affect the gas price for controlling DDoS attacks on the network according to the price volatility of the native coin WEMIX. Of course, it is possible to change the fixed gas price by on-chain Governance, but it cannot be dealt with promptly and involves the risk of impairing the safety of the network. Therefore, in WEMIX3.0, we applied the EIP1559 protocol with the following conditions to protect the network from DDoS attacks and excessive transactions generated by the bots. In WEMIX3.0, the `BaseFee` and the `CurrentGasTarget` are calculated per block by the following equations: ![BaseFee and CurrentGasTarget](https://lh5.googleusercontent.com/2tIDcFT4AOfJNjB4DSIcPw45iMQvs3wYLWBLOMH4syPyj2JJJrjEJOUaOKrdD3pFESa1gLmCbQLkYpQy2BwVk7JUZudjgYnJnQm2KH3eqb-6JuVSsknwLIJjJzO6AWBQaSSGk17lIRoGJyyLu1M) The `baseFeeMaxChangeRate`(default: 55%) in the above formula is fixed but can be adjusted through the Governance. Also, to prevent the `BaseFee` from becoming infinite and all WEMIX being used as transaction fees, the maximum value of BaseFee, `maxBaseFee`(default: 50,000Gwei), has been set. This value can also be adjusted through Governance. ![Range of BaseFee](https://lh6.googleusercontent.com/GWC0MxTHa6RhVFH_QlzcCVlLxagVsk_C-x3alDiWBdGDHy2KZCffgowZHsdBOju-Zoz2TN5ryTph9jLn0VGrjYA8dLuSpRrXs_unWuSTyHAJG-GUsbBLJJ2NRuyebBl6jRYKXXwK3eE5A8_G2uo) In the formula below, `gasTargetPercentage`(default: 30%) and `PreviousGasLimit`(default: 105,000,000) are subject to change by governance voting but are always the same unless changed by Governance. ![GasTarget](https://lh3.googleusercontent.com/WWXd7x4zOq05_1Tmql9ChU-cLBNjBNJbJSf91B1wvQ6ar3Tye9cQfdh_nFGWTtw1UiP9yQcK5sQFgW52ovsxz2b7nsrlyxN3gDZwIBFthGdbAy_fL2R9ZSQBh0y_PFLWjILMRcymlEoJGM17YVQ) WEMIX3.0 users can generate transactions using the fixed gas price `maxPriorityFeePerGas`(default: 100Gwei) value and the variable gas price `BaseFee`(default: 1Gwei) value recorded in the latest block. This algorithm is compatible with all wallets that support EIP1559. # Eco Fund This chapter includes explanations about the Eco Fund allocated as 25% of the PMR(Permanent Minting Reward) generated within the WEMIX3.0 blockchain, as well as various programs aimed at stimulating ecosystem activation and network expansion. ## PoET The PoET Program, a PMR distribution program designed to incentivize builders and users who contribute to the growth of the WEMIX3.0 ecosystem and network, has been in operation since September 1, 2023. During its operation, the PoET Program played a significant role in fostering the growth of the WEMIX ecosystem thanks to the active participation of builders and users. However, in an effort to explore more strategic directions to further revitalize the ecosystem and undertake necessary restructuring, the PoET Program will be terminated on April 19, 2024. ### **Key Points Following PoET Program Termination** * Distribution of PoET rewards will cease after the PoET Program termination. * Existing accumulated PoET rewards can still be claimed and withdrawn through the claim function after April 19, 2024. ### Policy updates
DateContentNotes
September 1, 2023Program launched-
September 18, 2023PoET Distribution Policy updated-
March 7, 2024Distribution levels and builder/user allocation ratio updated-
April 19, 2024Program terminated-
# Fee Delegation This chapter is about Fee Delegation applied to WEMIX3.0. Fee Delegation is a mechanism applied to Applepie HF in WEMIX3.0. This is a feature that FeePayer pays a fee for the transaction that Sender wants to execute instead of Sender. Fee Delegation Transaction is accomplished by sending the existing Transaction signed by the Sender, including the FeePayer information, by adding the FeePayer signed signature information.

Fee Delegation

#### Fee Delegation Transaction {% code overflow="wrap" %} ``` DynamicFeeTxType Transaction(with signature of Sender) + FeePayer address + signature of FeePayer ``` {% endcode %} Fee Delegation Transaction only supports DynamicFeeTxType among existing Transaction and does not support LegacyTxType or AccessListTxType.
Important changes to implementation of Fee Delegation Transaction are as follows, and please refer to the open source for further information. #### Fee Delegation Transaction Type (transaction.go) ```go const ( LegacyTxType = iota AccessListTxType DynamicFeeTxType FeeDelegateDynamicFeeTxType = 22 //fee delegation ) ``` #### Fee Delegation Transaction Structure(transaction.go) ```go type FeeDelegateDynamicFeeTx struct { SenderTx DynamicFeeTx FeePayer *common.Address rlp:"nil" // Signature values FV *big.Int json:"fv" gencodec:"required" // feePayer V FR *big.Int json:"fr" gencodec:"required" // feePayer R FS *big.Int json:"fs" gencodec:"required" // feePayer S } ``` #### Fee Delegation Transaction Hash Function for Signature(transaction\_signing.go) ```go func (s feeDelegateSigner) Hash(tx *Transaction) common.Hash { senderV, senderR, senderS := tx.RawSignatureValues() return prefixedRlpHash( tx.Type(), []interface{}{ []interface{}{ s.chainId, tx.Nonce(), tx.GasTipCap(), tx.GasFeeCap(), tx.Gas(), tx.To(), tx.Value(), tx.Data(), tx.AccessList(), senderV, senderR, senderS, }, tx.FeePayer(), }) } ``` {% hint style="danger" %} **Caution** Fee Delegation Transaction pays fees according to the fee settings (gas, maxFeePerGas, maxPriorityFeePerGas) of DynamicFeeTxType Transaction generated by the Sender. Therefore, FeePayer must have a procedure to verify that the transaction fee is appropriate. {% endhint %} {% hint style="danger" %} **Caution** It is important to note that the nonce of the transaction requested by the user is greater than the nonce of the transaction requested by the current sender, because Fee Delegation Transaction signed by FeePayer may not be used immediately, depending on the nonce of the sender. {% endhint %} # Roadmap Decentralized Technology, Democratized Governance WEMIX3.0 mainnet, developed on a decentralized architecture, will introduce a multi-phase democratized governance where the community is empowered to impact the 40 authority node governance structure through the introduction of a delegated staking module. This is the fundamental principle of the mainnet's roadmap, a means to illustrate true democratization through adoption of meritocracy based on contribution to the ecosystem. ### Phase 01 Node Council Partners, also known as WONDERS, are 40 selected members who operate secured validating nodes for the WEMIX3.0 Mainnet. 40 WONDERS are constituted by Technology Sponsors that contribute to the secure operation and innovation of WEMIX3.0, and Ecosystem Sponsors that contribute to the establishment of the experience cycle created through the on-chain/off-chain ecosystem via WEMIX3.0. Each NCP must stake 1.5M WEMIX, and the PMR (Permanent Minting Reward) is distributed automatically to NCP (40%), Stakers (10%), Eco fund (25%) and Maintenance (25%). WEMIX Grand Staking will become available to the community which will yield the 10% Staking Reward allocated through the PMR. However, staking participants for the WEMIX Grand Staking may not withdraw from the staking pool prior to the implementation of Phase 2. ### Phase 02 (Current) Upon Phase 2 launch, 1.5M fixed WEMIX Staking per validator node is abolished and shifted to competitive staking to encourage active ecosystem contiributions from NCPs. The 10% PMR paid to WEMIX Grand Staking participants is abolished. As the NCP reward increases from 40% to 50%, the initial PMR distribution ratio changes. In doing so, WEMIX holders may then delegate their stake volume to one of the 40 validator nodes, effectively increasing the chosen node's total staked shares above the median; generating increased reward rate for the node and community members that are participating in the delegation. ### Phase 03 Validator node operation by 40 selected authority partners known as, WONDERS, will be discontinued and the governance module will shift into an open & autonomous node participation system where anyone can become the validators of WEMIX3.0 based on staking volume. Based on the total WEMIX staking volume per node, top 40 nodes will be periodically selected to validate transactions, transforming from an SPoA model into a PoS model. A slashing policy will be implemented to enforce fair operation of validator nodes, especially in the event of willful collusion against the interests of the ecosystem but also possible result of a misconfiguration of the node. Slashing will penalize the node by removing a portion of its existing stake and is irreversible. Democratized governance is completed at this stage, and the mainnet will be upgraded to WEMIX4.0. The schedule is yet to be determined. # Quick Start For software applications to interact with the WEMIX3.0 Blockchain(either by reading blockchain data or sending transactions to the network), they must connect to a WEMIX3.0 node. To connect to the WEMIX3.0 Blockchain Network, start the WEMIX3.0 Node(i.e., `gwemix`) and complete block sync from the neighboring node. After block sync is complete, users can create a new. And if you receive `TWEMIX`(Testnet WEMIX) for testing through Test Coin Faucet, you are ready for development. * [Start Node](/en/quick-start/start-node) * [Connect Node](/en/quick-start/connect-node) * [Account ](/en/quick-start/account) * [Testnet Faucet](/en/quick-start/testnet-faucet) # Start Node Anyone can download the pre-built WEMIX3.0 node binary in the Docker environment and run it directly on the Linux machine they manage. However, all users do not need to operate a node; for example, dApp developers can access the WEMIX3.0 blockchain using the Open API RPC server, which provides 24 hours service. * [Using binaries](/en/quick-start/start-node/use-binary) * [Connecting to a public RPC server](/en/quick-start/start-node/use-public-api-server-rpc) {% hint style="info" %} **Build** Please refer to the [Install Guide](/en/install-and-operation/end-node/install-guide) for developers building directly without using the binary provided by WEMIX. {% endhint %} {% hint style="info" %} **Spec** [Hardware specifications](/en/install-and-operation/block-producer-node/system-requirements) of the Linux machine on which the WEMIX3.0 binary node will run. {% endhint %} # Use Binary The WEMIX3.0 blockchain Binary Node can be [downloaded](/en/install-and-operation/download) from the site. Using the WEMIX3.0 network Run the following command: The default RPC port for `gwemix` is 8588, and the P2P port is 8589. Like geth, `--datadir` can specify the folder in which `chaindata` is stored, and if this value is omitted, `~/.wemix` becomes the data directory. {% tabs %} {% tab title="Mainnet" %} *gwemix --syncmode full --datadir {data\_folder} --http --http.addr 0.0.0.0* {% endtab %} {% tab title="Testnet" %} *gwemix --wemix-testnet --syncmode full --datadir {data\_folder} --http --http.addr 0.0.0.0* {% endtab %} {% endtabs %} {% hint style="info" %} **Command line option** Use the [command line option](/en/quick-start/start-node/use-binary/command-line-option). It is possible to run gwemix by specifying the settings. {% endhint %} # Command-line Option ``` NAME: gwemix - the go-wemix command line interface Copyright 2013-2022 The go-ethereum / go-metadium / go-wemix Authors USAGE: gwemix [options] [command] [command options] [arguments...] VERSION: 0.9.8-stable-afed9ee5 COMMANDS: account Manage accounts attach Start an interactive JavaScript environment (connect to node) console Start an interactive JavaScript environment db Low level database operations dump Dump a specific block from storage dumpconfig Show configuration values dumpgenesis Dumps genesis block JSON configuration to stdout export Export blockchain into file export-preimages Export the preimage database into an RLP stream import Import a blockchain file import-preimages Import the preimage database from an RLP stream init Bootstrap and initialize a new genesis block js Execute the specified JavaScript files license Display license information makecache Generate ethash verification cache (for testing) makedag Generate ethash mining DAG (for testing) removedb Remove blockchain and state databases show-deprecated-flags Show flags that have been deprecated snapshot A set of commands based on the snapshot version Print version numbers version-check Checks (online) whether the current version suffers from any known security vulnerabilities wallet Manage Ethereum presale wallets wemix Wemix helper commands help, h Shows a list of commands or help for one command ETHEREUM OPTIONS: --config value TOML configuration file --datadir value Data directory for the databases and keystore (default: "/home/nxt/.wemix") --datadir.ancient value Data directory for ancient chain segments (default = inside chaindata) --datadir.minfreedisk value Minimum free disk space in MB, once reached triggers auto shut down (default = --cache.gc converted to MB, 0 = disabled) --keystore value Directory for the keystore (default = inside the datadir) --usb Enable monitoring and management of USB hardware wallets --pcscdpath value Path to the smartcard daemon (pcscd) socket file (default: "/run/pcscd/pcscd.comm") --networkid value Explicitly set network id (integer, 1111=WemixMainnet , 1112=WemixTestnet)(For testnets: use --wemix-testnet --ropsten, --rinkeby, --goerli instead) (default: 1111) --mainnet Ethereum mainnet --wemix-testnet Wemix test network: pre-configured wemix test network --goerli Görli network: pre-configured proof-of-authority test network --rinkeby Rinkeby network: pre-configured proof-of-authority test network --ropsten Ropsten network: pre-configured proof-of-work test network --sepolia Sepolia network: pre-configured proof-of-work test network --syncmode value Blockchain sync mode ("snap", "full" or "light") (default: snap) --exitwhensynced Exits after block synchronisation completes --gcmode value Blockchain garbage collection mode ("full", "archive") (default: "full") --txlookuplimit value Number of recent blocks to maintain transactions index for (default = about one year, 0 = entire chain) (default: 2350000) --ethstats value Reporting URL of a ethstats service (nodename:secret@host:port) --identity value Custom node name --lightkdf Reduce key-derivation RAM & CPU usage at some expense of KDF strength --whitelist value Comma separated block number-to-hash mappings to enforce (=) LIGHT CLIENT OPTIONS: --light.serve value Maximum percentage of time allowed for serving LES requests (multi-threaded processing allows values over 100) (default: 0) --light.ingress value Incoming bandwidth limit for serving light clients (kilobytes/sec, 0 = unlimited) (default: 0) --light.egress value Outgoing bandwidth limit for serving light clients (kilobytes/sec, 0 = unlimited) (default: 0) --light.maxpeers value Maximum number of light clients to serve, or light servers to attach to (default: 100) --ulc.servers value List of trusted ultra-light servers --ulc.fraction value Minimum % of trusted ultra-light servers required to announce a new head (default: 75) --ulc.onlyannounce Ultra light server sends announcements only --light.nopruning Disable ancient light chain data pruning --light.nosyncserve Enables serving light clients before syncing DEVELOPER CHAIN OPTIONS: --dev Ephemeral proof-of-authority network with a pre-funded developer account, mining enabled --dev.period value Block period to use in developer mode (0 = mine only if transaction pending) (default: 0) --dev.gaslimit value Initial block gas limit (default: 11500000) ETHASH OPTIONS: --ethash.cachedir value Directory to store the ethash verification caches (default = inside the datadir) --ethash.cachesinmem value Number of recent ethash caches to keep in memory (16MB each) (default: 2) --ethash.cachesondisk value Number of recent ethash caches to keep on disk (16MB each) (default: 3) --ethash.cacheslockmmap Lock memory maps of recent ethash caches --ethash.dagdir value Directory to store the ethash mining DAGs (default: "/home/nxt/.ethash") --ethash.dagsinmem value Number of recent ethash mining DAGs to keep in memory (1+GB each) (default: 1) --ethash.dagsondisk value Number of recent ethash mining DAGs to keep on disk (1+GB each) (default: 2) --ethash.dagslockmmap Lock memory maps for recent ethash mining DAGs TRANSACTION POOL OPTIONS: --txpool.locals value Comma separated accounts to treat as locals (no flush, priority inclusion) --txpool.nolocals Disables price exemptions for locally submitted transactions --txpool.journal value Disk journal for local transaction to survive node restarts (default: "transactions.rlp") --txpool.rejournal value Time interval to regenerate the local transaction journal (default: 1h0m0s) --txpool.pricelimit value Minimum gas price limit to enforce for acceptance into the pool (default: 1) --txpool.pricebump value Price bump percentage to replace an already existing transaction (default: 10) --txpool.accountslots value Minimum number of executable transaction slots guaranteed per account (default: 100000) --txpool.globalslots value Maximum number of executable transaction slots for all accounts (default: 500000) --txpool.accountqueue value Maximum number of non-executable transaction slots permitted per account (default: 100000) --txpool.globalqueue value Maximum number of non-executable transaction slots for all accounts (default: 500000) --txpool.lifetime value Maximum amount of time non-executable transaction are queued (default: 3h0m0s) PERFORMANCE TUNING OPTIONS: --cache value Megabytes of memory allocated to internal caching (default = 4096 mainnet full node, 128 light mode) (default: 1024) --cache.database value Percentage of cache memory allowance to use for database io (default: 50) --cache.trie value Percentage of cache memory allowance to use for trie caching (default = 15% full mode, 30% archive mode) (default: 15) --cache.trie.journal value Disk journal directory for trie cache to survive node restarts (default: "triecache") --cache.trie.rejournal value Time interval to regenerate the trie cache journal (default: 1h0m0s) --cache.gc value Percentage of cache memory allowance to use for trie pruning (default = 25% full mode, 0% archive mode) (default: 25) --cache.snapshot value Percentage of cache memory allowance to use for snapshot caching (default = 10% full mode, 20% archive mode) (default: 10) --cache.noprefetch Disable heuristic state prefetch during block import (less CPU and disk IO, more time waiting for data) --cache.preimages Enable recording the SHA3/keccak preimages of trie keys ACCOUNT OPTIONS: --unlock value Comma separated list of accounts to unlock --password value Password file to use for non-interactive password input --signer value External signer (url or path to ipc file) --allow-insecure-unlock Allow insecure account unlocking when account-related RPCs are exposed by http API AND CONSOLE OPTIONS: --ipcdisable Disable the IPC-RPC server --ipcpath value Filename for IPC socket/pipe within the datadir (explicit paths escape it) --http Enable the HTTP-RPC server --http.addr value HTTP-RPC server listening interface (default: "localhost") --http.port value HTTP-RPC server listening port (default: 8588) --http.api value API's offered over the HTTP-RPC interface --http.rpcprefix value HTTP path path prefix on which JSON-RPC is served. Use '/' to serve on all paths. --http.corsdomain value Comma separated list of domains from which to accept cross origin requests (browser enforced) --http.vhosts value Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard. (default: "localhost") --ws Enable the WS-RPC server --ws.addr value WS-RPC server listening interface (default: "localhost") --ws.port value WS-RPC server listening port (default: 8598) --ws.api value API's offered over the WS-RPC interface --ws.rpcprefix value HTTP path prefix on which JSON-RPC is served. Use '/' to serve on all paths. --ws.origins value Origins from which to accept websockets requests --graphql Enable GraphQL on the HTTP-RPC server. Note that GraphQL can only be started if an HTTP server is started as well. --graphql.corsdomain value Comma separated list of domains from which to accept cross origin requests (browser enforced) --graphql.vhosts value Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard. (default: "localhost") --rpc.gascap value Sets a cap on gas that can be used in eth_call/estimateGas (0=infinite) (default: 0) --rpc.evmtimeout value Sets a timeout used for eth_call (0=infinite) (default: 5s) --rpc.txfeecap value Sets a cap on transaction fee (in ether) that can be sent via the RPC APIs (0 = no cap) (default: 0) --rpc.allow-unprotected-txs Allow for unprotected (non EIP155 signed) transactions to be submitted via RPC --jspath loadScript JavaScript root path for loadScript (default: ".") --exec value Execute JavaScript statement --preload value Comma separated list of JavaScript files to preload into the console NETWORKING OPTIONS: --bootnodes value Comma separated enode URLs for P2P discovery bootstrap --discovery.dns value Sets DNS discovery entry points (use "" to disable DNS) --port value Network listening port (default: 8589) --maxpeers value Maximum number of network peers (network disabled if set to 0) (default: 25) --maxpendpeers value Maximum number of pending connection attempts (defaults used if set to 0) (default: 0) --nat value NAT port mapping mechanism (any|none|upnp|pmp|extip:) (default: "any") --nodiscover Disables the peer discovery mechanism (manual peer addition) --v5disc Enables the experimental RLPx V5 (Topic Discovery) mechanism --netrestrict value Restricts network communication to the given IP networks (CIDR masks) --nodekey value P2P node key file --nodekeyhex value P2P node key as hex (for testing) MINER OPTIONS: --mine Enable mining --miner.threads value Number of CPU threads to use for mining (default: 0) --miner.notify value Comma separated HTTP URL list to notify of new work packages --miner.notify.full Notify with pending block headers instead of work packages --miner.gasprice value Minimum gas price for mining a transaction (default: 1000000000) --miner.gaslimit value Target gas ceiling for mined blocks (default: 8000000) --miner.etherbase value Public address for block mining rewards (default = first account) (default: "0") --miner.extradata value Block extra data set by the miner (default = client version) --miner.recommit value Time interval to recreate the block being mined (default: 3s) --miner.noverify Disable remote sealing verification GAS PRICE ORACLE OPTIONS: --gpo.blocks value Number of recent blocks to check for gas prices (default: 20) --gpo.percentile value Suggested gas price is the given percentile of a set of recent transaction gas prices (default: 60) --gpo.maxprice value Maximum transaction priority fee (or gasprice before London fork) to be recommended by gpo (default: 500000000000) --gpo.ignoreprice value Gas price below which gpo will ignore transactions (default: 2) VIRTUAL MACHINE OPTIONS: --vmdebug Record information useful for VM and contract debugging LOGGING AND DEBUGGING OPTIONS: --fakepow Disables proof-of-work verification --nocompaction Disables db compaction after import --verbosity value Logging verbosity: 0=silent, 1=error, 2=warn, 3=info, 4=debug, 5=detail (default: 3) --vmodule value Per-module verbosity: comma-separated list of = (e.g. eth/*=5,p2p=4) --log.json Format logs with JSON --log.backtrace value Request a stack trace at a specific logging statement (e.g. "block.go:271") --log.debug Prepends log messages with call-site location (file and line number) --pprof Enable the pprof HTTP server --pprof.addr value pprof HTTP server listening interface (default: "127.0.0.1") --pprof.port value pprof HTTP server listening port (default: 6060) --pprof.memprofilerate value Turn on memory profiling with the given rate (default: 524288) --pprof.blockprofilerate value Turn on block profiling with the given rate (default: 0) --pprof.cpuprofile value Write CPU profile to the given file --trace value Write execution trace to the given file METRICS AND STATS OPTIONS: --metrics Enable metrics collection and reporting --metrics.expensive Enable expensive metrics collection and reporting --metrics.addr value Enable stand-alone metrics HTTP server listening interface (default: "127.0.0.1") --metrics.port value Metrics HTTP server listening port (default: 6060) --metrics.influxdb Enable metrics export/push to an external InfluxDB database --metrics.influxdb.endpoint value InfluxDB API endpoint to report metrics to (default: "http://localhost:8086") --metrics.influxdb.database value InfluxDB database name to push reported metrics to (default: "geth") --metrics.influxdb.username value Username to authorize access to the database (default: "test") --metrics.influxdb.password value Password to authorize access to the database (default: "test") --metrics.influxdb.tags value Comma-separated InfluxDB tags (key/values) attached to all measurements (default: "host=localhost") --metrics.influxdbv2 Enable metrics export/push to an external InfluxDB v2 database --metrics.influxdb.token value Token to authorize access to the database (v2 only) (default: "test") --metrics.influxdb.bucket value InfluxDB bucket name to push reported metrics to (v2 only) (default: "geth") --metrics.influxdb.organization value InfluxDB organization name (v2 only) (default: "geth") WEMIX OPTIONS: --consensusmethod value Wemix consensus method (integer, 1=PoW, 2=PoA, 3=ETCD, 4=PBFT) (default: 2) --fixeddifficulty value Fixed difficulty to disable PoW (default: 1) --fixedgaslimit value Fixed gas limit to control block size better (default: 0) --maxidleblockinterval value Interval to generate empty block (default: 600) --blocksperturn value Number of blocks per turn for PoA (default: 100) --noncelimit value Nonce limit for non-governing accounts (default: 0) --userocksdb value LevelDB (0) or RocksDB (1) (default: 1) --prefetchcount value Transaction prefetch count for faster db read (default: 0) --log value Rotating log file: ,, (default: "log,5,10M") --maxtxsperblock value Max # of transactions in a block (default: 5000) --hub value Id of message hub --wemix.block.interval value Block generation interval in seconds (default: 1) --wemix.block.timeadjblocks value Block interval to ajdust timestamp (default: 120) --wemix.block.minbuildtime value Minimum block generation time in ms (default: 300) --wemix.block.minbuildtxs value Minimum txs in a block with pending txs (default: 2500) --wemix.block.trailtime value Time to leave for block data transfer in ms (default: 300) ALIASED (deprecated) OPTIONS: --nousb Disables monitoring for and managing USB hardware wallets (deprecated) MISC OPTIONS: --snapshot Enables snapshot-database mode (default = enable) --bloomfilter.size value Megabytes of memory allocated to bloom-filter for pruning (default: 2048) --help, -h show help --override.arrowglacier value Manually specify Arrow Glacier fork-block, overriding the bundled setting (default: 0) --override.terminaltotaldifficulty value Manually specify TerminalTotalDifficulty, overriding the bundled setting (default: 0) COPYRIGHT: Copyright 2013-2022 The go-ethereum / go-metadium / go-wemix Authors ``` # Use Public API Server(RPC) Not desiring to install and manage the WEMIX3.0 client, it is possible to use the RPC server WEMIX Foundation provides 24 hours a day for free. Developers can leverage RPC servers and public network endpoints to interact with on-chain data and send different types of transactions to the network. The API follows the JSON-RPC standard, a stateless and lightweight Remote Procedure Call (RPC) protocol commonly used when interacting with blockchain networks. {% hint style="info" %} **JSON-RPC calls** [WEMIX3.0 JSON-RPC API](/en/dapp-developer/json-rpc) is 100% compatible with standard Web3 [Ethereum JSON-RPC API](https://eth.wiki/json-rpc/API)**.** {% endhint %} {% tabs %} {% tab title="Mainnet" %} HTTP(HTTPS) server endpoint * WS(WSS) server endpoint * {% endtab %} {% tab title="Testnet" %} HTTP(HTTPS) server endpoint * WS(WSS) server endpoint * [wss://ws.test.wemix.com](wss://ws,test,wemix.com) {% endtab %} {% endtabs %} {% hint style="info" %} **Speed limit** Rate limiting is a function to limit the rate for incoming connections. For example, if too many references co-occur and burden the server, connections that exceed the defined rate limit may be rejected. The RPC server has a speed limit for each IP to prevent malicious attacks and provide reliable services to more users. {% endhint %} # Connect Node ## **Node Connection** The method to connect through the locally installed `gwemix` RPC web server is as follows. ``` gwemix attach rpc:http://localhost:8588 ``` The method to connect through the locally installed `gwemix` IPC file is as follows. ``` gwemix attach {data_folder}/gwemix.ipc ``` Downloading and unzipping the binary {data\_folder}, the shell script file called `gwemix.sh` is located under the bin directory. The method to connect to a node through an IPC file using `gwemix.sh` is as follows. ``` {data_folder}/bin/gwemix.sh console ``` ## **Node Settings** When using `gwemix.sh`, it is possible to set node execution options in advance by creating a file called `.rc` in {data\_folder}. ``` PORT=8588 DISCOVER=1 # 1 for enable discovery mode, 0 for disable discovery mode TESTNET=1 # 1 for Testnet or remove this line for Mainnet SYNC_MODE=full GWEMIX_OPTS="--rpc.allow-unprotected-txs" ``` Set up as above and run `gwemix`, `gwemix`will run with the following run line options. ``` gwemix --http.port 8588 --wemix-testnet --syncmode full --rpc.allow-unprotected-txs ``` # Account A WEMIX3.0 account is an object with a WEMIX balance that can send transactions from a WEMIX blockchain. This chapter describes how to create an External-Owned Account (EOA) and check the balance directly controlled by the user. ## **Create Account** Account files are created in the keystore directory. To create a new account, use the following command. ``` gwemix wemix new-account --out ``` {% hint style="info" %} MetaMask allows creating new accounts conveniently without having to install gwemix directly. Wallet creation and WEMIX3.0 network settings are possible [through MetaMask](/en/quick-start/account/use-metamask). {% endhint %} ## **Import Account** Account files created externally can also be copied and used in the keystore directory. ``` mkdir {data_directory}/keystore chmod 700 {data_directory}/keystore cp {data_directory}/keystore ``` ## **Check Account Balance** Access the gwemix console and run the following command to check the account balance. ``` eth.getBalance('{your_address}') ``` Because the gwemix console is a JavaScript console, a JavaScript function that reads all addresses in the Keystore can be used to read all balances as a function. ``` function checkAllBalances() { var i = 0; eth.accounts.forEach( function(e){ console.log("eth.accounts["+i+"]: " + e + " \tbalance: " + web3.fromWei(eth.getBalance(e), "ether") + " ether"); i++; }) }; ``` # Use MetaMask Creating a WEMIX3.0 wallet using MetaMask MetaMask is a wallet for general users that can perform send/receive functions of coin, FT, and NFT on WEMIX3.0 Mainnet/Testnet. In addition, developers can connect REMIX IDE through MetaMask to distribute smart contracts and conduct behavior tests. Let's proceed from installation to use in the following order. * Step 1: Install Metamask * Step 2: Launch Metamask * Step 3: Add WEMIX3.0 Network Information * Step 4: Send WEMIX Coin ## Step 1 : Install MetaMask Web users can download and install MetaMask from the [Chrome Web Store](https://chrome.google.com/webstore/category/extensions) and [Mozilla add-ons](https://addons.mozilla.org/en-US/firefox/), and mobile users can use the Apple App Store and Google Play Store. Users go to the MetaMask's [download page](https://metamask.io/download/), select the platform they want, and follow the instrument's installation instructions. The process is almost the same for all platforms, so in this section we will explain based on the MetaMask installed through the Chrome web store on Mac computers. ![](https://lh4.googleusercontent.com/RnF-mLqD4aRsnSh0jguxs55TE_1Lijq8ZFZ9VcsPT-I4IYFUWAVeBbfAmaDkSgShSKBUzvVeQCfjCgUvqxb37pgZeOqsndl_JOpxjWGGjV8irjwwWkbGDZQ1I0Y6-HW6mvjbtA) ## Step 2 : Launch MetaMask If metamask is successfully installed, it will be visible in the extensions tab at the top right. If you click MetaMask in the picture below, you will be taken to the MetaMask start screen. If MetaMask is successfully installed, it will be visible in the Extensions tab in the upper right corner. Pressing MetaMask in the figure below takes you to the MetaMask start screen. ![](https://lh4.googleusercontent.com/1CrLrcodMobrBIikw1vWUviujur6twBWa9zOroyVTahX31s1LhR1y-XI9JUgiVcawdrjxLhlp8DZjB_ffjPhFxda2lDzJVPpZn2z5lWrZwKvwckKJdRYWrXU6OxnLNOB_8xSBQ) Users who have previously created a wallet using MetaMask can select 'Import Wallet' and recover the wallet using the Secret Recovery Phase that they have backed up. On the other hand, new users press 'Create a Wallet'. The following is based on the case where 'Create a Wallet' is selected. First of all, you need to register 'Password' as shown in the picture below. The password is not stored on the server, but it is information that the user must remember, so please manage it carefully. Never store in a place that can be easily exposed. ![](https://lh5.googleusercontent.com/bPYjUVo4xUS9afKNBKq-c2m8gW-cBobqMmbfvBHIflw2Pv4NgLs9R8ITYTJDjuGeXJzqk8h7oLJQwouccAD3q5pEQ5nJOEuZKgwrNUFqqknKLqIlK68uQBcL14v8ae_-JO5YBg) Pressing 'Create' in the figure above creates 12 seed phrases (Secret Recovery Phrase). These 12 seed phrases are the 'secret key' of a wallet that stores multiple assets. Remember, this information should never be kept on devices connected to the Internet. In the event of device theft, loss, or failure, the wallet and funds will be unrecoverable without the seed phrase. On the next page, confirm that you have 'written it down'. ![](https://lh3.googleusercontent.com/RprVBTl3qctcSEPaVwQHrfupaUJYjDGp7THklZnCv5TQX3bl0138tfCmz-n-hkN78mPQzCJJ0P-peCxTJdlGhwamSSAwHUlZGMKovakPp-fxRvXjZszN1c022MpOJI5UejggLg) ## Step 3 : Add WEMIX3.0 Network Information If MetaMask is executed through the above procedure, you can see the screen below.
You can see that MetaMask basically supports Ethereum wallets. You cannot use it as a WEMIX wallet in these settings. Now, let's change the network from Ethereum to WEMIX3.0 Mainnet/Testnet. In Settings, let's connect WEMIX3.0 blockchain node to the MetaMask wallet.
In the figure below, you will be moved to the 'Networks' menu on the Settings screen. Then click 'Add a Network' and manually add WEMIX3.0 Mainnet or Testnet.

Added WEMIX3.0 Testnet Network

Added WEMIX3.0 Mainnet Network

The following parameters must be entered for each network: {% hint style="info" %} #### Testnet Network Name: WEMIX\_Testnet New RPC URL: ChainID: 1112 Symbol: tWEMIX Block Explorer URL: {% endhint %} {% hint style="info" %} #### Mainnet Network Name: WEMIX\_Mainnet New RPC URL: ChainID: 1111 Symbol: WEMIX Block Explorer URL: {% endhint %} To send WEMIX or TWEMIX using MetaMask, you can add both Mainnet and Testnet. When you save that network and return to the main screen, the network automatically changes to the information you enter and also the unit display is no longer ETH but WEMIX.
## Step 4 : Send WEMIX coin To send WEMIX coins, click the 'Send' button. Then, a window for entering the address you want to receive (Send to) appears. Enter the address you want to receive and record the amount you want to send in the 'Amount' field.
Enter the address and amount to receive and select 'Next', a screen showing 'Gas Fee' based on Ethereum will be displayed as shown below. WEMIX has a different fee policy than Ethereum, so press the 'EDIT' button to go to the screen below.
In the picture above, if 'Advanced Options' is selected, the user sets 'Max priority fee (GWEI)' and 'Max fee (GWEI)' manually.
Currently, WEMIX is using a fixed 'Max priority fee (GWEI)' and the value is 100. Max fee is a user-defined value and the minimum value is MaxPriorityFee+BASE\_FEE. BASE\_FEE in WEMIX is variable according to EIP-1559. Therefore, for a transaction to be successfully created, it is recommended to set it as follows. 1. Max base fee (GWEI) = 101 2. Max priority fee (GWEI) = 100 Check the check box to keep the value you changed. Complete the Fee setting in the figure above and select 'Save' to be ready for withdrawal. Selecting 'Confirm' creates a 'Send WEMIX' transaction and once confirmed by WEMIX Block Producers, it is included in the block and the transfer is complete. # Testnet Faucet ## Testnet Faucet The **WEMIX3.0 Testnet Faucet** is a free web service that provides funding for developing and experimenting with smart contracts on the blockchain network. Developers can obtain tWEMIX and tWEMIX$ without purchasing WEMIX on the mainnet, allowing them to test various features of the WEMIX ecosystem. Currently, the Testnet Faucet supports tWEMIX and tWEMIX$. tWEMIX serves as the native coin for the testnet and is essential for gas fees and other payments. tWEMIX$ is the official test stablecoin and can be used to experiment with functions related to stablecoins such as WEMIX.Fi, PNIX DEX, or Kurrency. {% hint style="danger" %} The tWEMIX and tWEMIX$ provided through the Testnet Faucet are only available for development and testing purposes and cannot be used on the mainnet. {% endhint %} ## Using the Testnet Faucet The Testnet Faucet is provided through a separate web page, and users can receive test funds to their MetaMask wallet address. By selecting either tWEMIX or tWEMIX$ and entering your wallet address, funds will be sent within approximately 10 seconds. When using the Faucet, 10 tWEMIX and 100 WEMIX$ are provided per transaction. You must use up all the funds provided in one transaction before being able to use the Faucet again. {% embed url="" %} {% hint style="info" %} You can find detailed instructions on how to use the Testnet Faucet to receive test coins in the [Receive Test Coin](/en/tutorial/receive-test-coin) section. {% endhint %} # Install & Operation This chapter contains instructions on installing and operating `gwemix`. Developers can download the binary from gwemix official Github repository, clone the source code, and install it when a Linux machine with minimum specifications is ready. Follow the instructions below to install the WEMIX client. * [End Node](/en/install-and-operation/end-node) * [Block Producer Node](/en/install-and-operation/block-producer-node) * [Download](/en/install-and-operation/download) * [Operation Guide](/en/install-and-operation/operation-guide) # End Node ## Target use * The contents included in this chapter are for users who directly install WEMIX3.0 blockchain end node and need to read and write data directly to the blockchain through the [JSON-RPC API](https://docs.wemix.com/en/install-and-operation/pages/v0rv3ntLeeKevFTmPAQA#wemix3.0-json-rpc-api) method. * If you are a general dApp developer or want to test, you can use the [public RPC server](/en/quick-start/start-node/use-public-api-server-rpc) provided for free instead of installing the blockchain end node yourself. * In general, the following cases require the installation and operation of blockchain end nodes. 1. Exchange operator 2. High-performance dApp developer ## Roles and functions * Validation of received block data * Synchronization of block data and status information * RPC, WS request processing * Forward the received transaction to the connected BN (Bridge Node) # System Requirements End Node The recommended and minimum hardware specifications for operating the WEMIX3.0 blockchain end node are as follows. Both physical servers or cloud virtual machines (VMs) similar to the recommended specifications below can be used. {% tabs %} {% tab title="Recommended" %} * vCPU: 16 core * RAM: 128 GB * Storage: Minimum 1TB SSD (must be expandable periodically) * Example: [Azure Virtual Machine Standard*E16d*v4](https://azureprice.net/vm/Standard_E16d_v4) {% endtab %} {% tab title="Minimum" %} * vCPU: 8 core * RAM: 64 GB * Storage: Minimum 1TB SSD (must be expandable periodically) * Example: [Azure Virtual Machine Standard*E8d*v4](https://azureprice.net/vm/Standard_E8d_v4) {% endtab %} {% endtabs %} {% hint style="info" %} **Storage** As the WEMIX network grows, so does the minimum storage requirements. We recommend using more than the minimum requirements to safely run the full nodes. The storage growth rate varies according to the TPS and transaction size of the WEMIX3.0 blockchain, so full node operators should periodically check the disk size. In general, you can operate with --gcmode full, which does not store the state information of all previous blocks, but if necessary, when operated with --gcmode archive, the chain data size increases several times faster than operating with --gcmode full. Thus, be careful about it. {% endhint %} {% hint style="info" %} **Operating system** It is officially recommended to install and run in a Linux-based environment. We plan to provide support for other operating systems in the future. {% endhint %} # Firewall Setting End Node ## EN security The outbound & inbound Security Groups that need to be set in the end node are as follows. * Outbound | SOURCE | DESTINATION | SERVICE | PROTOCOL | PORT | | ------ | ----------- | ------- | -------- | ---- | | EN | all | p2p | tcp, udp | 8589 | * Inbound | SOURCE | DESTINATION | SERVICE | PROTOCOL | PORT | | ------ | ----------- | ------- | -------- | ---- | | all | EN | p2p | tcp, udp | 8589 | | Dev | EN | rpc | tcp | 8588 | | Dev | EN | ws | tcp | 8598 | # Install Guide End Node ### Build WEMIX3.0 is implemented based on Ethereum, so the build method is the same as `go-ethereum`, except that `geth` has been changed to `gwemix`. First, the developer downloads the [`go-wemix`](https://github.com/wemixarchive/go-wemix) source code by executing the following command on the Linux machine. ``` git clone https://github.com/wemixarchive/go-wemix.git ``` After that, go to the go-wemix directory and run the command below to start `gwemix` build. Depending on the USE\_ROCKSDB option, it is built as Rocksdb or Leveldb. Since the two databases are not compatible, you must check the db type and version when using chain data received from another machine. This chapter is explained based on Ubuntu environment. To build gwemix from source code directly in Ubuntu environment, you need to follow the steps below. {% tabs %} {% tab title="Ubuntu 22.04 LTS" %} #### Dependency ``` sudo apt-get update sudo apt-get install -y build-essential golang ``` #### Rocksdb only ``` sudo apt-get install -y libsnappy-dev libjemalloc-dev cd /usr/lib/x86_64-linux-gnu/ sudo ln -sf libjemalloc.so.2 libjemalloc.so.1 ``` #### Download source code ``` git clone https://github.com/wemixarchive/go-wemix.git cd go-wemix ``` #### In case of rocksdb ``` make ``` #### In case of leveldb ``` make USE_ROCKSDB=NO ``` #### Copy and untar "build" to $GWEMIX\_HOME ``` GWEMIX_HOME='/opt/gwemix' sudo mkdir -p $GWEMIX_HOME sudo chown $USER:$USER $GWEMIX_HOME cp build/gwemix.tar.gz $GWEMIX_HOME/ cd $GWEMIX_HOME tar xvzf gwemix.tar.gz ``` #### Create .rc at $GWEMIX\_HOME with the following info ``` PORT=8588 DISCOVER=1 # 1 for enable discovery mode, 0 for disable discovery mode TESTNET=1 # 1 for Testnet or remove this line for Mainnet SYNC_MODE=full # snap, full or archive GWEMIX_OPTS="--maxpeers=100" ``` #### Start gwemix ``` $GWEMIX_HOME/bin/gwemix.sh start ``` #### Check log ``` tail -F $GWEMIX_HOME/logs/log ``` {% endtab %} {% tab title="Ubuntu 20.04.4 or 18.04.6 LTS" %} #### Dependency ``` sudo apt-get update sudo apt-get install -y build-essential ``` #### Rocksdb only ``` sudo apt-get install -y libsnappy-dev libjemalloc-dev cd /usr/lib/x86_64-linux-gnu/ sudo ln -sf libjemalloc.so.2 libjemalloc.so.1 ``` #### Install go version 1.18.4 ``` wget https://go.dev/dl/go1.18.4.linux-amd64.tar.gz sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.18.4.linux-amd64.tar.gz export PATH=$PATH:/usr/local/go/bin source $HOME/.profile ``` #### Download source code ``` git clone https://github.com/wemixarchive/go-wemix.git cd go-wemix ``` #### In case of rocksdb ``` make ``` #### In case of leveldb ``` make USE_ROCKSDB=NO ``` #### Copy and untar "build" to $GWEMIX\_HOME ``` GWEMIX_HOME='/opt/gwemix' sudo mkdir -p $GWEMIX_HOME sudo chown $USER:$USER $GWEMIX_HOME cp build/gwemix.tar.gz $GWEMIX_HOME/ cd $GWEMIX_HOME tar xvzf gwemix.tar.gz ``` #### Create .rc at $GWEMIX\_HOME with the following info ``` PORT=8588 DISCOVER=1 # 1 for enable discovery mode, 0 for disable discovery mode TESTNET=1 # 1 for Testnet or remove this line for Mainnet SYNC_MODE=full # snap, full or archive GWEMIX_OPTS="--maxpeers=100" ``` #### Start gwemix ``` $GWEMIX_HOME/bin/gwemix.sh start ``` #### Check log ``` tail -F $GWEMIX_HOME/logs/log ``` {% endtab %} {% endtabs %} When executing the `make`, `logrot` and `gwemix.tar.gz` are built at once for convenience of installation and are saved as compressed files in the `build` directory. The generated `gwemix.tar.gz` contains the following files. ``` bin/gwemix ## gwemix binary bin/gwemix.sh ## gwemix control shell script bin/logrot ## log rotator ``` ### **Build with Docker Image** WEMIX3.0 can use docker images to solve cases where library dependencies are a problem. When building on Linux or MacOS X, you can build it through the following process. {% hint style="info" %} Currently, docker build is not supported in Apple Chip MacOS environment and Windows environment, and support will be provided in the future. {% endhint %} {% tabs %} {% tab title="Rocksdb" %} ``` make USE_ROCKSDB=YES gwemix-linux ``` {% endtab %} {% tab title="Leveldb" %} ``` make USE_ROCKSDB=NO gwemix-linux ``` {% endtab %} {% endtabs %} To install the `gwemix.tar.gz` binary built through Docker by copying it to the Ubuntu environment, follow the steps below. {% tabs %} {% tab title="Ubuntu 22.04 or 20.04.4 LTS" %} #### Rocksdb only ``` sudo apt-get install -y libsnappy-dev libjemalloc-dev cd /usr/lib/x86_64-linux-gnu/ sudo ln -sf libjemalloc.so.2 libjemalloc.so.1 ``` #### Copy and untar "build" to $GWEMIX\_HOME ``` GWEMIX_HOME='/opt/gwemix' sudo mkdir -p $GWEMIX_HOME sudo chown $USER:$USER $GWEMIX_HOME cp build/gwemix.tar.gz $GWEMIX_HOME/ cd $GWEMIX_HOME tar xvzf gwemix.tar.gz ``` #### Create .rc at $GWEMIX\_HOME ``` PORT=8588 DISCOVER=1 # 1 for enable discovery mode, 0 for disable discovery mode TESTNET=1 # 1 for Testnet or remove this line for Mainnet SYNC_MODE=full # snap, full or archive GWEMIX_OPTS="--maxpeers=100" ``` #### Start gwemix ``` $GWEMIX_HOME/bin/gwemix.sh start ``` #### Check log ``` tail -F $GWEMIX_HOME/logs/log ``` {% endtab %} {% tab title="Ubuntu 18.04.6 LTS" %} #### Rocksdb only ``` sudo apt-get isntall libjemalloc1 ``` #### Copy and untar "build" to $GWEMIX\_HOME ``` GWEMIX_HOME='/opt/gwemix' sudo mkdir -p $GWEMIX_HOME sudo chown $USER:$USER $GWEMIX_HOME cp build/gwemix.tar.gz $GWEMIX_HOME/ cd $GWEMIX_HOME tar xvzf gwemix.tar.gz ``` #### Create .rc at $GWEMIX\_HOME ``` PORT=8588 DISCOVER=1 # 1 for enable discovery mode, 0 for disable discovery mode TESTNET=1 # 1 for Testnet or remove this line for Mainnet SYNC_MODE=full # snap, full or archive GWEMIX_OPTS="--maxpeers=100" ``` #### Start gwemix ``` $GWEMIX_HOME/bin/gwemix.sh start ``` #### Check log ``` tail -F $GWEMIX_HOME/logs/log ``` {% endtab %} {% endtabs %} # Block Producer Node ## Target use * This chapter is for NCPs (Node Council Partners) participating as BP nodes of the WEMIX3.0 blockchain. * BP nodes must perform the consensus process and quickly generate and propagate blocks, so hardware, network resources, and firewall policy requirements must be strictly met.

WEMIX3.0 Network Connection

# System Requirements Block Producer Node The hardware specifications for operating the WEMIX3.0 BP blockchain node are as follows. {% tabs %} {% tab title="HW specifications" %} * vCPU: 32 core * RAM: 256 GB * Storage: Minimum 2TB SSD (must be expandable periodically) * Recommended: [Azure Virtual Machine Standard\_*E32ds\_*v4 ](https://azureprice.net/vm/Standard_E32ds_v4) {% endtab %} {% endtabs %} {% hint style="info" %} **Specification** To safely operate BP nodes, you must use HW above the recommended requirements. For BP, it is recommended to operate with --syncmode full. {% endhint %} {% hint style="info" %} **Operating system** It is officially recommended to install and run in a Linux-based environment. We plan to provide support for other operating systems in the future. {% endhint %} # Firewall Setting Block Producer Node ## BP Node Security The outbound & inbound Security Groups that must be set in the BP node is as follows. * Outbound | SOURCE | DESTINATION | SERVICE | PROTOCOL | PORT | | ------ | ----------- | ------- | -------- | ---- | | BP | BP | p2p | tcp | 8589 | | BP | BP | etcd | tcp | 8590 | * Inbound | SOURCE | DESTINATION | SERVICE | PROTOCOL | PORT | | ------ | ----------- | ------- | -------- | ---- | | BP | BP | p2p | tcp | 8589 | | BP | BP | etcd | tcp | 8590 | | PN | BP | p2p | tcp | 8589 | The list of BPs and PNs that need to be applied to the Security Group will be delivered separately as a document when BP is installed. # Install Guide Block Producer Node ### Build WEMIX3.0 is implemented based on Ethereum, so the build method is the same as `go-ethereum`, except that `geth` has been changed to `gwemix`. The installation method of BP is the same as that of EN and uses the same binary. Therefore, it proceeds to build in the same procedure. First, the developer downloads the [`go-wemix`](https://github.com/wemixarchive/go-wemix) source code by executing the following command on the Linux machine. ``` git clone https://github.com/wemixarchive/go-wemix.git ``` After that, go to the go-wemix directory and run the command below to start `gwemix` build. Depending on the USE\_ROCKSDB option, it is built as Rocksdb or Leveldb. Since the two databases are not compatible, you must check the db version when using chain data received from another machine. This chapter is based on Ubuntu environment. To build gwemix from source code directly in Ubuntu environment, you need to follow the steps below. {% tabs %} {% tab title="Ubuntu 22.04 LTS" %} #### Dependency ``` sudo apt-get update sudo apt-get install -y build-essential golang ``` #### Rocksdb only ``` sudo apt-get install -y libsnappy-dev libjemalloc-dev cd /usr/lib/x86_64-linux-gnu/ sudo ln -sf libjemalloc.so.2 libjemalloc.so.1 ``` #### Download source code ``` git clone https://github.com/wemixarchive/go-wemix.git cd go-wemix ``` #### In case of rocksdb ``` make ``` #### In case of leveldb ``` make USE_ROCKSDB=NO ``` #### Copy and untar "build" to $GWEMIX\_HOME ``` GWEMIX_HOME='/opt/gwemix' sudo mkdir -p $GWEMIX_HOME sudo chown $USER:$USER $GWEMIX_HOME cp build/gwemix.tar.gz $GWEMIX_HOME/ cd $GWEMIX_HOME tar xvzf gwemix.tar.gz ``` #### Create .rc at $GWEMIX\_HOME with the following info ``` PORT=8588 DISCOVER=1 # 1 for enable discovery mode, 0 for disable discovery mode TESTNET=1 # 1 for Testnet or remove this line for Mainnet SYNC_MODE=full GWEMIX_OPTS="--txpool.nolocals --snapshot=false --maxpeers=100" ``` #### Start gwemix ``` $GWEMIX_HOME/bin/gwemix.sh start ``` #### Check log ``` tail -F $GWEMIX_HOME/logs/log ``` {% endtab %} {% tab title="Ubuntu 20.04.4 or 18.04.6 LTS" %} #### Dependency ``` sudo apt-get update sudo apt-get install -y build-essential ``` #### Rocksdb only ``` sudo apt-get install -y libsnappy-dev libjemalloc-dev cd /usr/lib/x86_64-linux-gnu/ sudo ln -sf libjemalloc.so.2 libjemalloc.so.1 ``` #### Install go version 1.18.4 ``` wget https://go.dev/dl/go1.18.4.linux-amd64.tar.gz sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.18.4.linux-amd64.tar.gz export PATH=$PATH:/usr/local/go/bin source $HOME/.profile ``` #### Download source code ``` git clone https://github.com/wemixarchive/go-wemix.git cd go-wemix ``` #### In case of rocksdb ``` make ``` #### In case of leveldb ``` make USE_ROCKSDB=NO ``` #### Copy and untar "build" to $GWEMIX\_HOME ``` GWEMIX_HOME='/opt/gwemix' sudo mkdir -p $GWEMIX_HOME sudo chown $USER:$USER $GWEMIX_HOME cp build/gwemix.tar.gz $GWEMIX_HOME/ cd $GWEMIX_HOME tar xvzf gwemix.tar.gz ``` #### Create .rc at $GWEMIX\_HOME with the following info ``` PORT=8588 DISCOVER=1 # 1 for enable discovery mode, 0 for disable discovery mode TESTNET=1 # 1 for Testnet or remove this line for Mainnet SYNC_MODE=full GWEMIX_OPTS="--txpool.nolocals --snapshot=false --maxpeers=100" ``` #### Start gwemix ``` $GWEMIX_HOME/bin/gwemix.sh start ``` #### Check log ``` tail -F $GWEMIX_HOME/logs/log ``` {% endtab %} {% endtabs %} When executing the `make`, `logrot` and `gwemix.tar.gz` are built at once for convenience of installation and are saved as compressed files in the `build` directory. The generated `gwemix.tar.gz` contains the following files. ``` bin/gwemix ## gwemix binary bin/gwemix.sh ## gwemix control shell script bin/logrot ## log rotator ``` ### **Build with Docker Image** WEMIX3.0 can use docker images to solve cases where library dependencies are a problem. When building on Linux or MacOS X, you can build it through the following process. {% hint style="info" %} Currently, docker build is not supported in Apple Chip MacOS environment and Windows environment, and support will be provided in the future. {% endhint %} {% tabs %} {% tab title="Rocksdb" %} ``` make USE_ROCKSDB=YES gwemix-linux ``` {% endtab %} {% tab title="Leveldb" %} ``` make USE_ROCKSDB=NO gwemix-linux ``` {% endtab %} {% endtabs %} To install the `gwemix.tar.gz` binary built through Docker by copying it to the Ubuntu environment, follow the steps below. {% tabs %} {% tab title="Ubuntu 22.04 or 20.04.4 LTS" %} #### Rocksdb only ``` sudo apt-get install -y libsnappy-dev libjemalloc-dev cd /usr/lib/x86_64-linux-gnu/ sudo ln -sf libjemalloc.so.2 libjemalloc.so.1 ``` #### Copy and untar "build" to $GWEMIX\_HOME ``` GWEMIX_HOME='/opt/gwemix' sudo mkdir -p $GWEMIX_HOME sudo chown $USER:$USER $GWEMIX_HOME cp build/gwemix.tar.gz $GWEMIX_HOME/ cd $GWEMIX_HOME tar xvzf gwemix.tar.gz ``` #### Create .rc at $GWEMIX\_HOME ``` PORT=8588 DISCOVER=1 # 1 for enable discovery mode, 0 for disable discovery mode TESTNET=1 # 1 for Testnet or remove this line for Mainnet SYNC_MODE=full GWEMIX_OPTS="--txpool.nolocals --snapshot=false --maxpeers=100" ``` #### Start gwemix ``` $GWEMIX_HOME/bin/gwemix.sh start ``` #### Check log ``` tail -F $GWEMIX_HOME/logs/log ``` {% endtab %} {% tab title="Ubuntu 18.04.6 LTS" %} #### Rocksdb only ``` sudo apt-get isntall libjemalloc1 ``` #### Copy and untar "build" to $GWEMIX\_HOME ``` GWEMIX_HOME='/opt/gwemix' sudo mkdir -p $GWEMIX_HOME sudo chown $USER:$USER $GWEMIX_HOME cp build/gwemix.tar.gz $GWEMIX_HOME/ cd $GWEMIX_HOME tar xvzf gwemix.tar.gz ``` #### Create .rc at $GWEMIX\_HOME ``` PORT=8588 DISCOVER=1 # 1 for enable discovery mode, 0 for disable discovery mode TESTNET=1 # 1 for Testnet or remove this line for Mainnet SYNC_MODE=full GWEMIX_OPTS="--txpool.nolocals --snapshot=false --maxpeers=100" ``` #### Start gwemix ``` $GWEMIX_HOME/bin/gwemix.sh start ``` #### Check log ``` tail -F $GWEMIX_HOME/logs/log ``` {% endtab %} {% endtabs %} # Download ## Blockchain client binary for Linux * [gwemix v0.10.0](https://github.com/wemixarchive/go-wemix/releases/tag/w0.10.0) * [gwemix v0.10.1](https://github.com/wemixarchive/go-wemix/releases/tag/w0.10.1) * [gwemix v0.10.2](https://github.com/wemixarchive/go-wemix/releases/tag/w0.10.2) * [gwemix v0.10.3](https://github.com/wemixarchive/go-wemix/releases/tag/w0.10.3) * [gwemix v0.10.4](https://github.com/wemixarchive/go-wemix/releases/tag/w0.10.4) * [gwemix v0.10.5](https://github.com/wemixarchive/go-wemix/releases/tag/w0.10.5) ### Chaindata (Rocksdb Only) Chaindata of WEMIX3.0 mainnet and testnet can be downloaded p2p by running gwemix client. However, as the size of blockchain data continues to increase, the time required for synchronization is also increasing. Therefore, for the convenience of users, the WEMIX Foundation provides chaindata of WEMIX3.0 mainnet and testnet by daily backup and compression. After downloading the chaindata through the link below, you can use it by unzipping it in the `$GWEMIX_HOME/geth` directory. * [Mainnet](https://packages.wemix.com/) * [Testnet](https://packages.test.wemix.com/) # Operation Guide Start/Stop/Restart EN The binary file of the WEMIX3.0 client node (i.e., `gwemix`) can be controlled using the following command. ### Start This is a command to run the built `gwemix`using script (i.e., `gwemix.sh`). ``` {data_directory}/bin/gwemix.sh start ``` When `gwemix` is executed with the above command, a log file with a size of 10MB is automatically saved in the `{data_folder}/log` directory. Up to 6 log files are saved, and this number can be changed in `gwemix.sh`. ### Stop This is a command to stop running `gwemix`. ``` {data_directory}/bin/gwemix.sh stop ``` ### Restart This is a command to stop and start `gwemix`in operation. ``` {data_directory}/bin/gwemix.sh restart ``` ### Remove data This is a command to delete all `chaindata` of `gwemix` in operation. **Please note that all `chaindata` will be removed by this operation.** ``` {data_directory}/bin/gwemix.sh wipe ``` ### Console access This is a command to access `gwemix` JavaScript console. ``` {data_directory}/bin/gwemix.sh console ``` ### Log The status of the current `gwemix`can be identified using the log file. ``` tail -F {data_folder}/logs/log ``` The log level is divided from 1 to 5 and the default is 3. ``` 0=silent, 1=error, 2=warn, 3=info, 4=debug, 5=detail (default: 3) ``` To change the log level, access the gwemix console and execute the command below to apply immediately. ``` debug.verbosity({log_level}) ``` # dApp Developer This section introduces the environment and usage for smart contract development provided by WEMIX3.0 for dApp development. It introduces the WEMIX3.0 API provided through Ethereum 100% compatible JSON-RPC and Open API server. # Smart Contract WEMIX3.0 provides the same smart contract environment as Ethereum. This chapter explains how to introduce and use Solidity, precompiled contracts provided by WEMIX3.0, and write, deploy, and test simple contracts. # Solidity This chapter describes the Solidity language and development environment. Solidity is an advanced object-oriented language for implementing smart contracts, a program that controls the behavior of accounts within Ethereum states. Solidity is a bracket-type language influenced by C++, Python, and JavaScript designed to work with Ethereum Virtual Machines(EVMs). Solidity is statically typed and supports inheritance, library, and complex user-defined types, among other features. Solidity allows creating contracts for purposes such as voting, crowdfunding, blind auctions, and multi-signed wallets. ### Integrated Development Environment(IDE) Various environments support Solidity. It can be used by installing Solidity Plugin from browser-based Remix to popular IDE tools such as IntelliJ and Visual Studio. #### **How to use Remix** Go to and: Storage.sol, Owner.sol, and Ballot.sol are shown in the contracts directory, and to create a new smart contract, select it to erase it and create a new file. ![Remix Home Screen](/files/C8sPEQopkPeRAmF4X4l3) Create and view the following example smart contracts: The example Smart Contract provides the ability to read count values through the `get()` function and raise or lower count values through the `inc()`, and `dec()` functions. ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.11; contract Counter { uint256 count; constructor(uint256 _count) { count = _count; } function get() public view returns (uint256) { return count; } function inc() public { count += 1; } function dec() public { count -= 1; } } ``` ![Writing Sample](/files/Jxn7OmSbkrMxQR2dD26u) Once the code is written, compile after selecting the correct compiler version on the Solidity Compiler screen. ![Compile Sample code](/files/953VDgVjbmTKu2AY17HY) From the Deploy & Run Transactions screen, you can select the environment you want to deploy and deploy Smart Contract to test it. The figure below is an example of a deployment to the WEMIX3.0 testnet using the "Injected Provider-Metamask" provided by Remix. ![Sample code](/files/HnKZYwgEAwZSDS31NrS5) If you are using MetaMask, you must add WEMIX3.0 Testnet as follows: The gas fee of WEMIX3.0 Testnet is different from Ethereum, so you need to change it when you send it. You can change Max fee to 100 GWEI and Max priority fee to 100.000000001 GWEI. For more information about adding networks and setting gas costs, see [Use MetaMask](/en/quick-start/account/use-metamask). # Precompiled Contracts The WEMIX3.0 Blockchain provides pre-compiled contracts. There are precompiled contracts in WEMIX smart contracts. The compiled contract provides contracts deployed in Ethereum and newly supported by WEMIX. ## Recovery of ECDSA signature The 0x01 address provides a function to recover the public key of the elliptic curve digital signature algorithm. The hash value of the transaction and the v, r, s signature value are entered, and the address is returned. The contract address distributed on the WEMIX3.0 testnet is 0xD37d47514f46efaCa967fc191D040B3ee713110A, which can be found through testnet explorer. ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.10; contract Ecrecover { address addressTest = 0x12Cb274aAD8251C875c0bf6872b67d9983E53fDd; bytes32 msgHash = 0xc51dac836bc7841a01c4b631fa620904fc8724d7f9f1d3c420f0e02adf229d50; uint8 v = 0x1b; bytes32 r = 0x44287513919034a471a7dc2b2ed121f95984ae23b20f9637ba8dff471b6719ef; bytes32 s = 0x7d7dc30309a3baffbfd9342b97d0e804092c0aeb5821319aa732bc09146eafb4; function verify() public view returns(bool) { // Use ECRECOVER to verify address return (ecrecover(msgHash, v, r, s) == (addressTest)); } } ``` ## SHA256 Hash function The 0x02 address provides an SHA-256 hash function. When the data is entered, the corresponding SHA-256 hash value is returned. The contract address distributed on the WEMIX3.0 testnet is 0xdbec92984EE8508e3A47C150C5BDBF02B8928A72, which can be found through testnet explorer. ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.10; contract Sha256hash { bytes32 public expectedHash = 0x7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069; function calculateHash() internal pure returns (bytes32) { string memory word = 'Hello World!'; bytes32 hash = sha256(bytes (word)); return hash; } function checkHash() public view returns(bool) { return (calculateHash() == expectedHash); } } ``` ## RIPEMD160 Hash function The 0x03 address provides a RIPEMD-160 hash function. When data is entered, the corresponding RIPEMD-160 hash value is returned. The contract address distributed on the WEMIX3.0 testnet is 0x39b2CB921353097993e72e811A5FC4992b72e926, which can be found through testnet explorer. ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.10; contract Ripmd160 { bytes20 public expectedHash = hex'8476ee4631b9b30ac2754b0ee0c47e161d3f724c'; function calculateHash() internal pure returns (bytes20) { string memory word = 'Hello World!'; bytes20 hash = ripemd160(bytes (word)); return hash; } function checkHash() public view returns(bool) { return (calculateHash() == expectedHash); } } ``` ## Data Copy function The 0x04 address provides a data copy function. This feature is used as a more reasonable way to copy data to memory. Currently, Solidity does not support the dataCopy function, so it must be called in-line assembly. The contract address distributed on the WEMIX3.0 testnet is 0x709Ba0DD7055BC61B781Ddda31F5Df0018F33391, which can be found through testnet explorer. ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.10; contract Datacopy { bytes public memoryStored; function callDatacopy(bytes memory data) public returns (bytes memory) { bytes memory result = new bytes(data.length); assembly { let len := mload(data) if iszero(call(gas(), 0x04, 0, add(data, 0x20), len, add(result,0x20), len)) { invalid() } } memoryStored = result; return result; } } ``` ## Modular Exponentiation function The 0x05 address provides a function to raise the integer `b` (base) to `e-`square (exponential) and calculate the remainder when divided by a positive integer `m` (modulus). The Solidity Compiler does not support this and must be called an inline assembly. The contract address distributed on the WEMIX3.0 testnet is 0x370AF3a491f1D7cc08D7cc590bB2a746E612a216, which can be found through testnet explorer. ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.10; contract ModularCheck { uint public checkResult; // Function to Verify ModExp Result function verify( uint _base, uint _exp, uint _modulus) public { checkResult = modExp(_base, _exp, _modulus); } function modExp(uint256 _b, uint256 _e, uint256 _m) public returns (uint256 result) { assembly { // Free memory pointer let pointer := mload(0x40) // Define length of base, exponent and modulus. 0x20 == 32 bytes mstore(pointer, 0x20) mstore(add(pointer, 0x20), 0x20) mstore(add(pointer, 0x40), 0x20) // Define variables base, exponent and modulus mstore(add(pointer, 0x60), _b) mstore(add(pointer, 0x80), _e) mstore(add(pointer, 0xa0), _m) // Store the result let value := mload(0xc0) // Call the precompiled contract 0x05 = bigModExp if iszero(call(not(0), 0x05, 0, pointer, 0xc0, value, 0x20)) { revert(0, 0) } result := mload(value) } } } ``` ## Point addition on Elliptic curve The 0x06 address provides a function that implements an addition operation for points on an elliptic curve. This operation receives two valid points(ax,ay) and(bx,by) on the elliptic curve bn256 and returns the point(ax,ay)+(bx,by) on the elliptic curve as a result. The Solidity Compiler does not support this function and must be called an inline assembly. The contract address distributed on the WEMIX3.0 testnet is 0x557359e169E56aAcb0d1E5FA9A7E8717967FcEbD, which can be found through testnet explorer. ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.10; contract BnAddCheck { bytes32[2] public checkResult; // Function to Verify ModExp Result function verify(uint ax, uint ay, uint bx, uint by) public { bytes32[4] memory input; input[0] = bytes32(ax); input[1] = bytes32(ay); input[2] = bytes32(bx); input[3] = bytes32(by); checkResult = callBn256Add(input[0], input[1], input[2], input[3]); } function callBn256Add(bytes32 ax, bytes32 ay, bytes32 bx, bytes32 by) public returns (bytes32[2] memory result) { bytes32[4] memory input; input[0] = ax; input[1] = ay; input[2] = bx; input[3] = by; assembly { let success := call(gas(), 0x06, 0, input, 0x80, result, 0x40) switch success case 0 { revert(0,0) } } } } ``` ## Point multiplication on Elliptic curve The 0x07 address provides a function that implements a multiplication operation for points on an elliptic curve expressed as scalar values. This operation takes a valid point(x,y) on the elliptic curve bn256 and returns the point scalar \* (x,y) on the elliptic curve. The Solidity Compiler does not support this function and must be called as inline assembly. ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.10; contract BnMulCheck { bytes32[2] public checkResult; // Function to Verify ModExp Result function verify(uint x, uint y, uint scalar) public { bytes32[3] memory input; input[0] = bytes32(x); input[1] = bytes32(y); input[2] = bytes32(scalar); checkResult = callBn256ScalarMul(input[0], input[1], input[2]); } function callBn256ScalarMul(bytes32 x, bytes32 y, bytes32 scalar) public returns (bytes32[2] memory result) { bytes32[3] memory input; input[0] = x; input[1] = y; input[2] = scalar; assembly { let success := call(not(0), 0x07, 0, input, 0x60, result, 0x40) switch success case 0 { revert(0,0) } } } } ``` ## Elliptic curve pairing function for zkSNARK validation The 0x08 address provides a function for elliptic curve peering operations to validate the zkSNARK proposed in EIP-197. The Solidity Compiler does not support this function and must be called as inline assembly. ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.10; contract BnPairingCheck { ... function pairing(G1Point[] memory p1, G2Point[] memory p2) public returns (bool) { require(p1.length == p2.length); uint elements = p1.length; uint inputSize = elements * 6; uint[] memory input = new uint[](inputSize); for (uint i = 0; i < elements; i++) { input[i * 6 + 0] = p1[i].X; input[i * 6 + 1] = p1[i].Y; input[i * 6 + 2] = p2[i].X[0]; input[i * 6 + 3] = p2[i].X[1]; input[i * 6 + 4] = p2[i].Y[0]; input[i * 6 + 5] = p2[i].Y[1]; } uint[1] memory out; bool success; assembly { success := call(gas(), 0x08, 0, add(input, 0x20), mul(inputSize, 0x20), out, 0x20) switch success case 0 { invalid() } } require(success); return out[0] != 0; } ... } ``` # Sample Contracts This chapter describes how to write and deploy smart contracts using truffle. ### **Creating Smart Contracts** This chapter describes how to create and distribute smart contracts using Truffle. ### **How to use Truffle** #### 1. Installation Install truffle using NPM, the Node Package Manager. Please refer to the following link for how to install npm: ``` $ npm install --g truffle ``` #### 2. Initialization ``` $ truffle init ``` When truffle init is performed, a truffle project is created. The Truffle project consists of build/contracts, contracts, migrations, tests, and truffle-config.js. * build/contracts: The result of compiling the contract written in solidity (abi, bytecode) is saved * contract: smart contract solidity files * migrations: deploy code(js format) * test: test code(js format) * truffle-config.js: Configuration such as solidity compiler version setting, network setting, etc Performing truffle init, the example solidity code called Migrations.sol is created as follows in the contract folder. To deploy the written smart contract, the user must first compile the written smart contract. ``` pragma solidity >=0.4.22 <0.9.0; contract Migrations { address public owner = msg.sender; uint public last_completed_migration; modifier restricted() { require( msg.sender == owner, "This function is restricted to the contract's owner" ); _; } function setCompleted(uint completed) public restricted { last_completed_migration = completed; } } ``` #### 3. Settings You must modify the truffle-config.js file for compilation and deployment. 3.1 Account Settings Add HDWalletProvider and privKeys in the Truflle-config.js file for settings for the account you want to use for deployment. Private keys can be imported after creating an account through the Web Wallet (). ``` const HDWalletProvider = require('@truffle/hdwallet-provoder'); const privKeys = ["privatekey from Web Wallet"]; ``` 3.2 Network Settings To use the WEMIX3.0 Testnet, add the network settings as follows: ``` networks: { wemix_testnet: { provider: ()=> new HDWalletProvider(privKeys, "https://api.test.wemix.com"), network_id: 1112, maxFeePerGas: 100000000010, maxPriorityFeePerGas: 100000000000 } }, ``` 3.3 Compiler Settings Set the last Solidity compiler version you want to use. The current version is 0.8.x, and the example uses 0.8.11. If it is installed directly on the operating system using the compiler, you can comment on the docker setting just like the initial setting. To install using docker, set "docker: true" as shown below and docker should be installed. If you use the optimizer, you can un-annotate and set the appropriate settings. ``` compilers: { solc: { version: "0.8.11", // Fetch exact version from solc-bin (default: truffle's version) docker: true, // Use "0.5.1" you've installed locally with docker (default: false) // settings: { // See the solidity docs for advice about optimization and evmVersion // optimizer: { // enabled: false, // runs: 200 // }, // evmVersion: "byzantium" } } ``` #### 4. Write a Solidity code Here is a simple smart contract example that increments or decrements the count variable and retrieves its value. Save it as Counter.sol. ``` pragma solidity ^0.8.0; contract Counter { uint256 count; constructor(uint256 _count) { count = _count; } function get() public view returns (uint256) { return count; } function inc() public { count += 1; } function dec() public { count -= 1; } } ``` #### 5. compile a Solidity code When truffle compile \ is performed in the truffle project folder, it compiles the target solidity file. The compiled solidity contracts are stored in the build/contracts folder as \.json format. ``` truffle compile ex) truffle compile Counter.sol ``` #### 6. Deploy a smart contract To distribute the compiled contract file to the blockchain, write the script and save it as 2\_deploy\_contracts.js: ``` var Counter = artifacts.require("./Counter.sol"); module.exports = function(deployer) { deployer.deploy(Counter, 10) .then(() => Counter.deployed()); }; ``` Deploy a contract individually by loading them as artifacts.require (\) and performing developer.deploy(contract\_artifacts, {constructor arguments}). ``` truffle migrate ex) truffle migrate 1_initial_migration.js ``` The deployment script can be executed with the truffle migrate \. If not used, it is performed in numerical order used in the script name. The results of the deployment on WEMIX3.0 Testnet are as follows: For deployment, the account that you want to use for deployment must have WEMIX. You can receive the required WEMIX from WEMIX-Faucet at . ``` ❯ truffle migrate --reset --network wemix_testnet Compiling your contracts... =========================== > Everything is up to date, there is nothing to compile. Starting migrations... ====================== > Network name: 'wemix_testnet' > Network id: 1112 > Block gas limit: 105000000 (0x6422c40) 1_initial_migration.js ====================== Replacing 'Migrations' ---------------------- > transaction hash: 0x8f57dc573afbf1e33b75b2f05282aac9152be70cee292c31c94877397cf27d82 > Blocks: 0 Seconds: 0 > contract address: 0x09C38aaf3AF7Dba9Cc2B755d75Acccf4A5b7bECC > block number: 428504 > block timestamp: 1658480854 > account: 0x435AaB89A2878102fDf894dA3e5F3b4454FF9772 > balance: 9.926666599999266666 > gas used: 250142 (0x3d11e) > gas price: 100.000000001 gwei > value sent: 0 ETH > total cost: 0.025014200000250142 ETH > Saving migration to chain. > Saving artifacts ------------------------------------- > Total cost: 0.025014200000250142 ETH 2_deploy_contracts.js ===================== Deploying 'Counter' ------------------- > transaction hash: 0x893fcc06e298b95ff145c90311c5d36a3f8c511470e73a753d13195ea9dae051 > Blocks: 0 Seconds: 0 > contract address: 0x76F3A4DFD8741E765Bf27Cd0BaaE26f64c192765 > block number: 428508 > block timestamp: 1658480857 > account: 0x435AaB89A2878102fDf894dA3e5F3b4454FF9772 > balance: 9.904089499999040895 > gas used: 179858 (0x2be92) > gas price: 100.000000001 gwei > value sent: 0 ETH > total cost: 0.017985800000179858 ETH > Saving migration to chain. > Saving artifacts ------------------------------------- > Total cost: 0.017985800000179858 ETH Summary ======= > Total deployments: 2 > Final cost: 0.04300000000043 ETH ``` #### 7. Test a smart contract The deployed contract can be tested through the javascript file as follows. ``` const migration = artifacts.require("Migrations"); contract("Migration", async () => { describe("Migration test", async () => { it("setCompleted", async () => { const migrations = await migration.deployed(); await migrations.setCompleted(0); }); }); }); ``` * contract : test target contact * describe : test case set * it : Individual test case ``` truffle test ``` When the test code is completed, save the test file as \ format in the test folder, and perform the truffle test \ to perform the test. # JSON-RPC For software applications to interact with the WEMIX3.0 blockchain, such as reading blockchain data or sending transactions to the network, they must connect to a WEMIX3.0 node. To do this, all WEMIX3.0 clients implement the JSON-RPC specification, providing a set of methods the application can use. JSON-RPC is a lightweight Remote Procedure Call(RPC) protocol without storing state. It is a transport method that can be used in multiple environments. It defines various data structures and processing rules and can be used within the same process, on sockets or HTTP, or in different message passing environments. Use JSON(RFC 4627) as the data format. ## WEMIX3.0 API Specifications The WEMIX3.0 API specification is 100% compatible with the Ethereum API, and for more information, see the link to the Ethereum API specification. ## WEMIX3.0 JSON-RPC API The WEMIX3.0 JSON-RPC API method is 100% compatible with Ethereum. Please refer to the link below for details. # API Reference This chapter describes the APIs provided through the WEMIX Explorer Open API Server. The provided API types include Account API, Block API, Contract API, Transaction API, Event logs API, Tokens API, etc. * [Account APIs](/en/dapp-developer/api-reference/account-apis) * [Block APIs](/en/dapp-developer/api-reference/block-apis) * [Contract APIs](/en/dapp-developer/api-reference/contract-apis) * [Transaction APIs](/en/dapp-developer/api-reference/transaction-apis) * [Event logs APIs](/en/dapp-developer/api-reference/event-logs-apis) * [Tokens APIs](/en/dapp-developer/api-reference/tokens-apis) The WEMIX Developer APIs are provided as a community service and without warranty, so please just use what you need and no more. \ They support both GET/POST requests and a rate limit of 120 requests/m. To use the API service, use the API key below. {% hint style="info" %} **API Key** 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 {% endhint %} {% hint style="success" %} Either a link back or mention that your app is "Powered by Wemix.io APIs" is required if used in commercial applications or sites. {% endhint %} # Account APIs ### Get WEMIX Balance for a single address #### URI
networkuri
MainnetPOST https://explorerapi.wemix.com/v1/accounts/balance
TestnetPOST https://explorerapi.test.wemix.com/v1/accounts/balance
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | -------------- | ---------------- | ------------ | | *Content-Type* | application/json | true | | *api-key* | api key | true | * **BODY(application/json)** | **key** | **type** | **value** | **required** | | ----------- | ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------ | | *addresses* | List\ |

Address of account: - min : 1

- max : 20

| true | #### REQUEST SAMPLE ``` POST https://explorerapi.test.wemix.com/v1/accounts/balance api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 Content-Type: application/json { "addresses" : [ "0x76C6E4A0a2A141343c370D5d36276DA643B0c829", "0xcD07A6d6A8DE7CdD3F5E1224eBC3540f70AEC52f" ] } ``` #### **RESPONSE PARAMETER** | **key** | **type** | **value** | | ---------------------- | ------------- | --------------------------- | | *status* | String | Status of request | | *message* | String | Response Message of request | | *results* | Json | Results of request | | *results.data* | List\ | List of data | | *results.data.address* | String | Address of account | | *results.data.balance* | String | Balance of address | #### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "data": [ { "address": "0x76C6E4A0a2A141343c370D5d36276DA643B0c829", "balance": "999999999989999999999589997401953799975191356000" }, { "address": "0xcD07A6d6A8DE7CdD3F5E1224eBC3540f70AEC52f", "balance": "10000000000009000000000000000004" } ] } } ``` ### Get list of transactions by address. #### **URI**
networkuri
MainnetGET https://explorerapi.wemix.com/v1/accounts/{address_hash}/transactions
Testnet

GET

https://explorerapi.test.wemix.com/v1/accounts/{address_hash}/transactions

#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api key | true | * **PATH VARIABLE**
keytypevaluerequired
address_hashString
  • Address(sender/receiver/contract)
true
* **QUERY STRING**
keytypevaluerequired
limitIntegerMaximum number of record will retrieve Default: 50, Max: 1000 false
offsetIntegerStart retrieve record Default: 0false
startBlockStringStart block Default: nullfalse
endBlockStringEnd block Default: nullfalse
inputBooleanInclude input data - true - Default: falsefalse
simpleBooleanInclude data simple - true - Default: falsefalse
conditionString

Address condition

- Default: all

- to

- from

- contract

#### REQUEST SAMPLE ``` GET https://explorerapi.wemix.com/v1/accounts/0xBbAB376Fd9c3a0f5ef1D2114c8dd1512FD858ee2/transactions api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER** | **key** | **type** | **include data *****simple*** | **value** | | ------------------------------------------- | ------------- | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *status* | String | | Status of request | | *message* | String | | Response Message of request | | *reuslts* | Json | | Results of request | | *reuslts.count* | String | | Total count of data | | *reuslts.data* | List\ | | List of data | | *results.data.timestamp* | String | | UTC time when the transaction occurred | | *results.data.nonce* | String | | Number of transaction requests | | *results.data.sender* | String | O | Address of sender | | *results.data.receiver* | String | O | Address of receiver | | *results.data.value* | *String* | | Value of transaction | | *results.data.confirmations* | String | | Block height | | *results.data.transaction\_hash* | String | O | Hash value of the transaction | | *results.data.block\_hash* | String | | Hash value of the block | | *results.data.transaction\_index* | String | | Index of the transaction on the block | | *results.data.tx\_status* | String | O | Status of the transaction: - 0: Failed, - 1: Success | | *results.data.tx\_message* | String | | Message when executing transaction | | results.data.in\_tx\_status | String | | Status of internal transaction. - 0: Failed, - 1: Success | | *results.data.in\_tx\_message* | String | | Message when executing internal transaction | | *results.data.tx\_fee* | String | O | Fee of executing the transaction | | *results.data.block\_number* | String | O | Number of block that contains the transaction | | *results.data.contract\_address* | String | | Address of contract creation if this is create contract transaction | | *results.data.gas\_limit* | String | | Limit of gas for executing the transaction | | *results.data.gas\_price* | String | O | Gas price of transaction | | *results.data.cumulative\_gas\_used* | String | O | Total amount of gas used when transaction was executed in the block. | | results.data.gas\_used | String | | Total amount of Gas used transactions | | *results.data.max\_fee\_per\_gas* | String | | Maximum (priority fee + base fee) limit | | *results.data.max\_priority\_fee\_per\_gas* | String | | Maximum priority fee limit | | *results.data.input* | String | | ABI encoding of transaction data | | *results.data.to\_block* | String | O | Lookup block(add simple only) | | *results.data.from\_block* | String | O | Start block(add simple only) | #### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "count": "23712", "data": [ { "timestamp": "2022-12-28T00:08:23Z", "sender": "0xac4783dcf53c1fb67e152c300390d61ea8b3e1d3", "receiver": "0x0898a80d55e4de9d398193d0f6aa788b9790e8d3", "value": "0", "confirmations": "6070555", "transaction_hash": "0x56e18258a7fa25ca232402c708926bfb44a1cea4ead4d5803cadea0d8aaaa2b4", "block_hash": "0x886565489899cb867f054a1ed301c190687776a265824065c055f799e69a570f", "transaction_index": "0", "tx_status": "0", "block_number": "14133850", "gas_price": "110000000000", "cumulative_gas_used": "67884", "gas_used": "67884", "max_fee_per_gas": "110000000000", "max_priority_fee_per_gas": "110000000000" }, ... ] } } ``` #### **RESPONSE SAMPLE(Simple Transaction)** ``` { "status": "200", "message": "success", "results": { "count": "23712", "data": [ { "sender": "0xac4783dcf53c1fb67e152c300390d61ea8b3e1d3", "receiver": "0x0898a80d55e4de9d398193d0f6aa788b9790e8d3", "transaction_hash": "0x56e18258a7fa25ca232402c708926bfb44a1cea4ead4d5803cadea0d8aaaa2b4", "tx_status": "1", "tx_fee": "7467240000000000", "block_number": "14133850", "gas_price": "110000000000", "gas_used": "67884" }, ... ], "to_block": "20204526" } } ``` ### Get "Internal Transactions" by address #### **URI**
networkuri
MainnetGET https://explorerapi.wemix.com/v1/accounts/{address_hash}/internal-transactions
TestnetGET https://explorerapi.test.wemix.com/v1/accounts/{address_hash}/internal-transactions
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api key | true | * **PATH VARIABLE** | **key** | **type** | **value** | **required** | | --------------- | -------- | --------------------------------------------------- | ------------ | | *address\_hash* | String |
  • Address(sender/receiver/contract)
| true | * **QUERY STRING** | **key** | **type** | **value** | **required** | | ------------ | -------- | ----------------------------------------------------------------------------------- | -------------------- | | *limit* | Integer | Maximum number of record will retrieve Default: 50, Max: 1000 | false | | *offset* | Integer | Start retrieve record Default: 0 | false | | *startBlock* | String | Start block Default: null |

false

| | *endBlock* | String | End block Default: null |

false

| | *input* | Boolean | Include input data Default: false | false | #### REQUEST SAMPLE ``` GET https://explorerapi.wemix.com/v1/accounts/0xBEd789c6008F788a28fc222C83082D67033Daf7F/internal-transactions?input=true api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER** | **key** | **type** | **value** | | --------------------------------- | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *status* | String | Status of request | | *message* | String | Response Message of request | | *results* | Json | Results of request | | *results.count* | String | Total count of data | | *results.data* | List\ | List of data | | *results.data.timestamp* | String | UTC time when the transaction occurred | | *results.data.sender* | String | Address of sender | | *results.data.receiver* | String | Address of receiver | | *results.data.value* | String | Value of internal transaction | | *results.data.status* | String | Status of internal transaction - 0: Failed, - 1: Success | | *results.data.message* | String | Message of internal transaction | | *results.data.transaction\_hash* | String | Hash value of the transaction | | *results.data.block\_number* | String | Block height | | *results.data.contract\_address* | String | Address of contract creation if this is create contract transaction | | *results.data.trace\_address* | List\ | Trace mapping information | | *results.data.trace\_type* | String | Type of trace: call, delegatecall, codecall, staticcall, selfdestruct | | *results.data.sub\_traces* | String | Number of sub traces from this internal transaction | | *results.data.transaction\_index* | String | Index of the transaction on the block | | *results.data.gas\_used* | String | Total amount of Gas used transactions | | *results.data.gas\_limit* | String | Limit of gas for executing the transaction | | *results.data.external\_receiver* | String | Whether external receive has occurred - false: external transaction exists - true: external transaction does not exist | | results.data.input | String | Input parameters used when executing a transaction | #### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "count": "2047", "data": [ { "timestamp": "2023-02-15T06:24:53Z", "sender": "0xbed789c6008f788a28fc222c83082d67033daf7f", "receiver": "0x53b690b826d611884d40f68252236d7c23d32d53", "value": "0", "status": "0", "message": null, "transaction_hash": "0x985512f6e0729d28ccdd568f6e9b7486b63aa0926cd4dbd9852b5899e9d27f7e", "block_number": "10207545", "contract_address": null, "trace_address": [ "0", "1" ], "trace_type": "delegatecall", "sub_traces": null, "transaction_index": "0", "gas_used": "43323", "gas_limit": "81177", "external_receiver": false "input": "0xbac4f3380000000000000000000000007ad5ffaa39d3638fc775bb118d1092caa210fcbf" ] } } ``` ### Get a list of "ERC20 - Token Transfer Events" by address #### **URI**
networkuri
MainnetGET https://explorerapi.wemix.com/v1/accounts/{address_hash}/token-transfer/erc20
TestnetGET https://explorerapi.test.wemix.com/v1/accounts/{address_hash}/token-transfer/erc20
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api key | true | * **PATH VARIABLE** | **key** | **type** | **value** | **required** | | --------------- | -------- | ------------------------------------------------------------------------------- | ------------------- | | *address\_hash* | String |
  • Address(sender/receiver/contract)
  • Transaction Address
|

true

| * **QUERY STRING** | **key** | **type** | **value** | **required** | | ------------ | -------- | --------------------------------------------------------------------------------------------------------- | ------------ | | *limit* | Integer | Maximum number of record will retrieve Default: 50, Max: 1000 | false | | *offset* | Integer | Start retrieve record Default: 0 | false | | *startBlock* | String | Start Block Default: null | false | | *endBlock* | String | End Block Default: null | false | #### REQUEST SAMPLE ``` GET https://explorerapi.test.wemix.com/v1/accounts/0x43dc58449beb06bf350e0181703c617f0bfa78bf/token-transfer/erc20 api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER**
keytypevalue
statusStringStatus of request
messageStringMessage of request
resultsJsonResults of request
results.countStringTotal count of data
results.dataList<Object>List of data
results.data.timestampStringUTC time when the transaction occurred
results.data.senderStringAddress of sender
results.data.receiverStringAddress of receiver
results.data.valueStringTransfer value
results.data.confirmationsStringNumber of block's confirmation
results.data.block_numberStringBlock number
results.data.transaction_hashStringHash of transaction
results.data.block_hashStringHash of block
results.data.token_addressStringToken creation if this is create token contract address
results.data.token_nameStringName of token
results.data.token_symbolStringSymbol of token
results.data.token_decimalsStringDecimals of token
results.data.transaction_indexStringIndex of transaction
#### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "count": "2", "data": [ { "timestamp": "2023-01-19T12:35:54Z", "sender": "0x43dc58449beb06bf350e0181703c617f0bfa78bf", "receiver": "0x05ceb79bf4cd7a24bbe6066d9e54c643b9cb1108", "value": "0", "confirmations": "4126491", "block_number": "16079523", "transaction_hash": "0x626c86c34db077d68131094d9768abf3cd03be3267d1a967e4352835ab09f73e", "block_hash": "0x2795a79f72ddd47c729fefd36797713e4de3fc25b24e70357d59612abc5ac961", "token_address": "0x01199b488fa05df702eee426b14d1cfdbd7b746d", "token_name": null, "token_symbol": null, "token_decimals": null, "transaction_index": "0" }, { "timestamp": "2023-01-18T14:40:32Z", "sender": "0xd9a370dd275181b47e39d6e88625d44f2eb1a466", "receiver": "0x43dc58449beb06bf350e0181703c617f0bfa78bf", "value": "0", "confirmations": "4205414", "block_number": "16000600", "transaction_hash": "0x5077a2519f8c8e6cf6bce16c6228068063b86fc54a771371d8d79a2d88267bde", "block_hash": "0x23fda9b7bc8aabe59ccfd56a67d7660a927a576e65866c0fb8bdeff0cbd24909", "token_address": "0x32637199e54e5b79990d84a0d2a161ec22ac1068", "token_name": null, "token_symbol": null, "token_decimals": null, "transaction_index": "0" } ] } } ``` ### Get a list of "ERC721 - Token Transfer Events" by address #### **URI**
networkuri
MainnetGET https://explorerapi.wemix.com/v1/accounts/{address_hash}/token-transfer/erc721
TestnetGET https://explorerapi.test.wemix.com/v1/accounts/{address_hash}/token-transfer/erc721
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api key | true | * **PATH VARIABLE** | **key** | **type** | **value** | **required** | | --------------- | -------- | ------------------------------------------------------------------------------- | ------------------- | | *address\_hash* | String |
  • Address(sender/receiver/contract)
  • Transaction Address
|

true

| * **QUERY STRING** | **key** | **type** | **value** | **required** | | ------------ | -------- | --------------------------------------------------------------------------------------------------------- | ------------ | | *limit* | Integer | Maximum number of record will retrieve Default: 50, Max: 1000 | false | | *offset* | Integer | Start retrieve record Default: 0 | false | | *startBlock* | String | Start Block Default: null | false | | *endBlock* | String | End Block Default: null | false | #### REQUEST SAMPLE ``` GET https://explorerapi.test.wemix.com/v1/accounts/0x43dc58449beb06bf350e0181703c617f0bfa78bf/token-transfer/erc721 api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER**
keytypevalue
statusStringStatus of request
messageStringMessage of request
resultsJsonResults of request
results.countStringTotal count of data
results.dataList<Object>List of data
results.data.timestampStringUTC time when the transaction occurred
results.data.senderStringAddress of sender
results.data.receiverStringAddress of receiver
results.data.confirmationsStringNumber of block's confirmation
results.data.block_numberStringBlock number
results.data.transaction_hashStringHash of transaction
results.data.block_hashStringHash of block
results.data.token_addressStringToken creation if this is create token contract address
results.data.token_nameStringName of token
results.data.token_symbolStringSymbol of token
results.data.token_decimalsStringDecimals of token
results.data.transaction_indexStringIndex of transaction
#### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "count": "3", "data": [ { "timestamp": "2023-01-12T05:40:28Z", "sender": "0x0000000000000000000000000000000000000000", "receiver": "0x43dc58449beb06bf350e0181703c617f0bfa78bf", "confirmations": "18158317", "block_number": "15449790", "transaction_hash": "0x288e7082ed9eb284391566d6212e224d1a345d2a2a7471329959714334cca67a", "block_hash": "0xebc8a7e50a4ac1d631e1a1bf8ec73944b87086be04c8e787274c469638a9a66c", "token_address": "0xd05f171995fa2ce44f2bc765e120fed1430a538f", "token_name": "MyNFT", "token_symbol": "NFT", "token_decimals": null, "transaction_index": "0" }, { "timestamp": "2023-01-12T03:38:33Z", "sender": "0x0000000000000000000000000000000000000000", "receiver": "0x43dc58449beb06bf350e0181703c617f0bfa78bf", "confirmations": "18165632", "block_number": "15442475", "transaction_hash": "0x3249ccb59cb5986941b4a84503ab29ae45995cc43278163ac5f6ea1301eca07f", "block_hash": "0x4dfbc1eefee42cc5541543ecbfe40e9bc88ab17c3d839eefc62fff0bb8b85f1b", "token_address": "0x3665731c515974eee182618c48bbdec847063627", "token_name": "MyNFT", "token_symbol": "NFT", "token_decimals": null, "transaction_index": "0" }, { "timestamp": "2023-01-12T03:16:14Z", "sender": "0x0000000000000000000000000000000000000000", "receiver": "0x43dc58449beb06bf350e0181703c617f0bfa78bf", "confirmations": "18166971", "block_number": "15441136", "transaction_hash": "0x3f1585e992b5ba4bc4f60419faa25bbc3e2ea839e0b8484d17a87b32765f5a9b", "block_hash": "0x0ecb317f27d0f14022215ebf75f763398aac6ef538182383f2389183e5a6344a", "token_address": "0x3665731c515974eee182618c48bbdec847063627", "token_name": "MyNFT", "token_symbol": "NFT", "token_decimals": null, "transaction_index": "0" } ] } } ``` ### Get ERC20/ERC721 Token List for a single address #### URI
networkuri
MainnetGET https://explorerapi.wemix.com/v1/accounts/{address_hash}/tokens
TestnetGET https://explorerapi.test.wemix.com/v1/accounts/{address_hash}/tokens
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api-key | true | * **PATH VARIABLE** | **key** | **type** | **value** | **required** | | --------------- | -------- | ----------------------- | ------------ | | *address\_hash* | String | address of token holder | true | * **QUERY STRING** | **key** | **type** | **value** | **required** | | -------- | -------- | --------------------------------------------------------------------------------------------------------- | ------------ | | *limit* | Number | Maximum number of record will retrieve Default: 50 | false | | *offset* | Number | Start retrieve record Default: 0 | false | #### **REQUEST SAMPLE** ``` GET https://explorerapi.test.wemix.com/v1/accounts/0xB20d32637296190A4A492dddB4Af2b0f03Df24F1/tokens api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER** | **key** | **type** | **value** | | ---------------------------------- | ------------- | ---------------------- | | *erc\_20* | List\ | List of ERC-20 | | *erc\_20.count* | String | Count of ERC-20 Lists | | *erc\_20.results* | Json | Results of request | | *erc\_20.results.balance* | String | Balance | | *erc\_20.results.token\_address* | String | Address of token | | *erc\_20.results.holder\_address* | String | Address of holder | | *erc\_20.results.holder\_type* | String | Type of token | | *erc\_20.results.token\_decimals* | String | Decimal of token | | *erc\_721* | List\ | List of ERC-721 | | *erc\_721.count* | String | Count of ERC-721 Lists | | *erc\_721.results* | Json | Results of request | | *erc\_721.results.balance* | String | Balance | | *erc\_721.results.token\_address* | String | Address of token | | *erc\_721.results.holder\_address* | String | Address of holder | #### **RESPONSE SAMPLE** ``` { "erc_20": { "count": "1", "results": [ { "balance": "4098808369498578418", "token_address": "0x4af286b2bf66ae46da121ffeb46c2a3bbe05dd97", "token_symbol": "TIPO", "token_name": "TIPOToken", "holder_address": "0xb20d32637296190a4a492dddb4af2b0f03df24f1", "holder_type": "0", "token_decimals": "18" } ] }, "erc_721": { "count": "1", "results": [ { "balance": "1", "token_address": "0x62E1Ad2A3A9AB55bA20Bc4EB27Fca655C41fDD88", "holder_address": "0xb20d32637296190a4a492dddb4af2b0f03df24f1" } ] } } ``` ### Get ERC20 Token List for a single address #### URI
networkuri
MainnetGET https://explorerapi.wemix.com/v1/accounts/{address_hash}/tokens/erc20
TestnetGET https://explorerapi.test.wemix.com/v1/accounts/{address_hash}/tokens/erc20
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api-key | true | * **PATH VARIABLE** | **key** | **type** | **value** | **required** | | --------------- | -------- | ----------------------- | ------------ | | *address\_hash* | String | address of token holder | true | * **QUERY STRING** | **key** | **type** | **value** | **required** | | -------- | -------- | --------------------------------------------------------------------------------------------------------- | ------------ | | *limit* | Number | Maximum number of record will retrieve Default: 50 | false | | *offset* | Number | Start retrieve record Default: 0 | false | #### **REQUEST SAMPLE** ``` https://explorerapi.test.wemix.com/v1/accounts/0x52d68c69b088dbc87e5e4f48e6f4df31f018685e/tokens/erc20 api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER** | **key** | **type** | **value** | | ----------------------------- | -------- | -------------------------- | | *status* | String | Status of request | | *messag*e | String | Message of request | | *results* | Json | Results of request | | *results.count* | String | Total count of ERC-20 List | | *results.data.token\_address* | String | Address of token | | *results.data.token\_name* | String | Name of token | | *results.data.token\_symbol* | String | Symbol of token | #### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "count": "68", "data": [ { "token_address": "0x3ebda066925bbc790fe198f47ef650ddb764ecfe", "token_name": "cWEMIX", "token_symbol": "cWEMIX" }, ... ] } } ``` ### Get ERC721 Token List for a single address #### URI
networkuri
MainnetGET https://explorerapi.wemix.com/v1/accounts/{address_hash}/tokens/erc721
TestnetGET https://explorerapi.test.wemix.com/v1/accounts/{address_hash}/tokens/erc721
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api-key | true | * **PATH VARIABLE** | **key** | **type** | **value** | **required** | | --------------- | -------- | ----------------------- | ------------ | | *address\_hash* | String | address of token holder | true | * **QUERY STRING** | **key** | **type** | **value** | **required** | | -------- | -------- | --------------------------------------------------------------------------------------------------------- | ------------ | | *limit* | Number | Maximum number of record will retrieve Default: 50 | false | | *offset* | Number | Start retrieve record Default: 0 | false | #### **REQUEST SAMPLE** ``` GET https://explorerapi.test.wemix.com/v1/accounts/0xB20d32637296190A4A492dddB4Af2b0f03Df24F1/tokens/erc721 api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER** | **key** | **type** | **value** | | ----------------------------- | -------- | --------------------------- | | *status* | String | Status of request | | *message* | String | Message of request | | *results* | Json | Results of request | | *results.count* | String | Total count of ERC-721 List | | *results.data.token\_address* | String | Address of token | | *results.data.token\_name* | String | Name of token | | *results.data.token\_symbol* | String | Symbol of token | #### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "count": "1", "data": [ { "token_address": "0x62e1ad2a3a9ab55ba20bc4eb27fca655c41fdd88", "token_name": "Tangled", "token_symbol": "TTPS" } ] } } ``` ### Get ERC721 Token Inventory of a specific ERC721 contract #### URI
networkuri
MainnetGET https://explorerapi.wemix.com/v1/accounts/{address_hash}/tokens/inventory/{token_address}
TestnetGET https://explorerapi.test.wemix.com/v1/accounts/{address_hash}/tokens/inventory/{token_address}
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api-key | true | * **PATH VARIABLE** | **key** | **type** | **value** | **required** | | ------------------- | -------- | ----------------------------------------- | ------------ | | *contract\_address* | String | Contract address requiring inventory list | true | | *token\_address* | String | Specific token address | false | * **QUERY STRING** | **key** | **type** | **value** | **required** | | -------- | -------- | --------------------------------------------------------------------------------------------------------- | ------------ | | *limit* | Number | Maximum number of record will retrieve Default: 50 | false | | *offset* | Number | Start retrieve record Default: 0 | false | #### **REQUEST SAMPLE** ``` GET https://explorerapi.test.wemix.com/v1/accounts/0xe3929888ddd76cefa78ac586a7749c7f5a86a143/tokens/inventory api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER** | **key** | **type** | **value** | | ------------------------------ | ------------- | ---------------------- | | *status* | String | Status of request | | *message* | String | Message of request | | *results* | Json | Results of request | | *results.count* | String | Count of inventory | | *results.data* | List\ | List of data | | results.data.contract\_address | String | token contract address | | *results.data.token\_id* | String | Id of token | | *results.data.token\_uri* | String | uri of token | | results.data.token\_name | String | token name | | results.data.token\_symbol | String | token symbol | #### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "count": "264", "data": [ { "contract_address": "0x5f240d896ef64a6a13ec6cd8e530f465943ae354", "token_id": "39", "token_uri": "https://nile.blob.core.windows.net/metadata/LUS/39.json", "token_name": "Sample", "token_symbol": "SAMPLE" } ... ] } } ``` ### Get list of Blocks Mined by address #### **URI**
networkuri
MainnetGET https://explorerapi.wemix.com/v1/accounts/{address_hash}/mined-blocks
TestnetGET https://explorerapi.test.wemix.com/v1/accounts/{address_hash}/mined-blocks
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api key | true | * **PARH VARIABLE** | **key** | **type** | **value** | **required** | | --------------- | -------- | ---------------- | ------------ | | *address\_hash* | String | Address of miner | true | * **QUERY STRING** | **key** | **type** | **value** | **required** | | -------- | -------- | --------------------------------------------------------------------------------------------------------- | ------------ | | *limit* | Number | Maximum number of record will retrieve Default: 50 | false | | *offset* | Number | Start retrieve record Default: 0 | false | #### REQUEST SAMPLE ``` GET https://explorerapi.test.wemix.com/v1/accounts/0xf04f49b134996023e980022502581c7278f3191a/mined-blocks api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER** | **key** | **type** | **value** | | --------------------------------- | ------------- | ----------------------------------------------- | | *status* | String | Status of request | | *message* | String | Message of request | | *results* | Json | Results of request | | *results.count* | String | Total count of data | | *results.data* | List\ | List of data | | *results.data.timestamp* | String | UTC time when the transaction occurred | | *results.data.miner* | String | Address of miner | | *results.data.reward* | String | Reward for miner when mining this block | | results.data.fees | String | Fee used when block was created | | *results.data.block\_number* | String | Block height | | *results.data.gas\_used* | String | Number of used gas | | *results.data.gas\_limit* | String | Number of limit gas | | *results.data.transaction\_count* | String | Number of transactions in the block | | results.data.mining\_reward | String | Rewards specified when blocks are created (pmr) | #### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "count": "1295039", "data": [ { "timestamp": "2023-08-10T09:50:47Z", "miner": "0xf04f49b134996023e980022502581c7278f3191a", "reward": "1000000000000000000", "fees": "0", "block_number": "33609019", "gas_used": "0", "gas_limit": "105000000", "transaction_count": "0", "mining_reward": "1000000000000000000" }, ... ] } } ``` # Block APIs ### Get Block And Uncle Rewards by block number #### URI
networkuri
MainnetGET https://explorerapi.wemix.com/v1/blocks/{block_number}
TestnetGET https://explorerapi.test.wemix.com/v1/blocks/{block_number}
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api-key | true | #### REQUEST SAMPLE ``` GET https://explorerapi.wemix.com/v1/blocks/6029508 api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 Content-Type: application/json ``` #### **RESPONSE PARAMETER**
keytypevalue
statusStringStatus value of request
messageStringMessage of request
resultsJsonResult of request
results.dataList<Object>List of data
results. data.timestampStringUTC time when the transaction occurred
results.data.minerStringAddress of block's miner
result.data.rewardStringReward of block
results.data.feesStringFee used when block was created
results.data.block_numberIntegerNumber of the block containing the transaction
results.data.mining_rewardStringRewards specified when blocks are created (pmr)
#### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "data": { "timestamp": "2022-12-28T21:51:44Z", "miner": "0x6ec14966480e3baf4c62a1f4532c95c42b07b9c9", "reward": "1000000000000000000", "fees": "0", "block_number": "6029508", "mining_reward": "1000000000000000000" } } } ``` # Contract APIs ### Get Contract ABI for Verified contract source code #### URI
networkuri
MainnetGET https://explorerapi.wemix.com/v1/contracts/{contract_address}/abi
TestnetGET https://explorerapi.test.wemix.com/v1/contracts/{contract_address}/abi
#### REQUEST PARAMETER * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api-key | true | * **PATH VARIABLE**
keytypevaluerequiredvalue
contract_addressStringVerified contract addresstrue
#### REQUEST SAMPLE ``` GET https://explorerapi.wemix.com/v1/contracts/0xB4EF146F31Bd7e680707658a9772D0cfD35c8df4/abi api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER**
keytypevaluevalue
statusStringStatus of request
messageStringResponse Message of request
resultsObjectResult of request
results.dataJsonContract abi
results.data.nameStringName of contract
results.data.typeStringType of contract
results.data.inputsStringArray of contract objects
results.data.inputs.nameStringName of parameter
results.data.inputs.typeStringType of parameter
results.data.inputs.internalTypeStringInternal type of parameter
results.data.outputStringArray similar to inputs
results.data.stateMutabilityStringBlockchain state value
#### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "data": [ { "type": "constructor", "inputs": [ { "name": "name", "type": "string", "internalType": "string" }, { "name": "symbol", "type": "string", "internalType": "string" } ], "stateMutability": "nonpayable" }, { "name": "Approval", "type": "event", "inputs": [ { "name": "owner", "type": "address", "indexed": true, "internalType": "address" }, { "name": "spender", "type": "address", "indexed": true, "internalType": "address" }, { "name": "value", "type": "uint256", "indexed": false, "internalType": "uint256" } ], "anonymous": false }, { "name": "Transfer", "type": "event", "inputs": [ { "name": "from", "type": "address", "indexed": true, "internalType": "address" }, { "name": "to", "type": "address", "indexed": true, "internalType": "address" }, { "name": "value", "type": "uint256", "indexed": false, "internalType": "uint256" } ], "anonymous": false }, { "name": "allowance", "type": "function", "inputs": [ { "name": "owner", "type": "address", "internalType": "address" }, { "name": "spender", "type": "address", "internalType": "address" } ], "outputs": [ { "name": "", "type": "uint256", "internalType": "uint256" } ], "stateMutability": "view" }, { "name": "approve", "type": "function", "inputs": [ { "name": "spender", "type": "address", "internalType": "address" }, { "name": "amount", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "nonpayable" }, { "name": "balanceOf", "type": "function", "inputs": [ { "name": "account", "type": "address", "internalType": "address" } ], "outputs": [ { "name": "", "type": "uint256", "internalType": "uint256" } ], "stateMutability": "view" }, { "name": "burn", "type": "function", "inputs": [ { "name": "account", "type": "address", "internalType": "address" }, { "name": "amount", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "nonpayable" }, { "name": "decimals", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "uint8", "internalType": "uint8" } ], "stateMutability": "view" }, { "name": "decreaseAllowance", "type": "function", "inputs": [ { "name": "spender", "type": "address", "internalType": "address" }, { "name": "subtractedValue", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "nonpayable" }, { "name": "increaseAllowance", "type": "function", "inputs": [ { "name": "spender", "type": "address", "internalType": "address" }, { "name": "addedValue", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "nonpayable" }, { "name": "name", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "string", "internalType": "string" } ], "stateMutability": "view" }, { "name": "symbol", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "string", "internalType": "string" } ], "stateMutability": "view" }, { "name": "totalSupply", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "uint256", "internalType": "uint256" } ], "stateMutability": "view" }, { "name": "transfer", "type": "function", "inputs": [ { "name": "to", "type": "address", "internalType": "address" }, { "name": "amount", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "nonpayable" }, { "name": "transferFrom", "type": "function", "inputs": [ { "name": "from", "type": "address", "internalType": "address" }, { "name": "to", "type": "address", "internalType": "address" }, { "name": "amount", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "nonpayable" } ] } } ``` ### Get contract source code for verified contract source code #### URI
networkuri
MainnetGET https://explorerapi.wemix.com/v1/contracts/{contract_address}/code
TestnetGET https://explorerapi.test.wemix.com/v1/contracts/{contract_address}/code
#### REQUEST PARAMETER * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api-key | true | * **PATH VARIABLE**
keytypevaluerequiredvalue
contract_addressStringVerified contract addresstrue
#### REQUEST SAMPLE ``` GET https://explorerapi.wemix.com/v1/contracts/0xB4EF146F31Bd7e680707658a9772D0cfD35c8df4/code api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER**
keytypevaluevalue
statusStringStatus of request
messageStringResponse Message of request
resultsJsonResults of request
results.dataList<Object>List of data
results.data.addressStringContract address
results.data.logoStringLogo set during contract code verification
results.data.compilerStringSolidity compiler version
results.data.librariesStringLibraries List
results.data.verify_dataStringContract code validation date
results.data.contract_nameStringName of contract
results.data.runs_optimizerStringValue of time which running optimizer
results.optimization_enabledStringIdentify if optimization is enable or not - 1: enable - Other number: not
results.data.contract_codeStringContract code deployed on the network
results.date.contract_abiJsonAbi of contract
results.data.contract_sourceStringSolidity contract code
constructor_argumentsStringArguments of constructor
reuslts.data.swam_sourceStringAddress of swarm source
reuslts.data.verify_statusStringContract code verify status
reuslts.data.verify_messageStringMessage written during contract code verification
#### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "data": { "address": "0xB4EF146F31Bd7e680707658a9772D0cfD35c8df4", "logo": null, "compiler": "0.8.10+commit.fc410830", "libraries": "[]", "verify_date": "2023-03-09T05:53:24Z", "contract_name": "MyToken", "runs_optimizer": "200", "optimization_enabled": "0", "contract_code": "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", "contract_abi": [ { "type": "constructor", "inputs": [ { "name": "name", "type": "string", "internalType": "string" }, { "name": "symbol", "type": "string", "internalType": "string" } ], "stateMutability": "nonpayable" }, { "name": "Approval", "type": "event", "inputs": [ { "name": "owner", "type": "address", "indexed": true, "internalType": "address" }, { "name": "spender", "type": "address", "indexed": true, "internalType": "address" }, { "name": "value", "type": "uint256", "indexed": false, "internalType": "uint256" } ], "anonymous": false }, { "name": "Transfer", "type": "event", "inputs": [ { "name": "from", "type": "address", "indexed": true, "internalType": "address" }, { "name": "to", "type": "address", "indexed": true, "internalType": "address" }, { "name": "value", "type": "uint256", "indexed": false, "internalType": "uint256" } ], "anonymous": false }, { "name": "allowance", "type": "function", "inputs": [ { "name": "owner", "type": "address", "internalType": "address" }, { "name": "spender", "type": "address", "internalType": "address" } ], "outputs": [ { "name": "", "type": "uint256", "internalType": "uint256" } ], "stateMutability": "view" }, { "name": "approve", "type": "function", "inputs": [ { "name": "spender", "type": "address", "internalType": "address" }, { "name": "amount", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "nonpayable" }, { "name": "balanceOf", "type": "function", "inputs": [ { "name": "account", "type": "address", "internalType": "address" } ], "outputs": [ { "name": "", "type": "uint256", "internalType": "uint256" } ], "stateMutability": "view" }, { "name": "burn", "type": "function", "inputs": [ { "name": "account", "type": "address", "internalType": "address" }, { "name": "amount", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "nonpayable" }, { "name": "decimals", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "uint8", "internalType": "uint8" } ], "stateMutability": "view" }, { "name": "decreaseAllowance", "type": "function", "inputs": [ { "name": "spender", "type": "address", "internalType": "address" }, { "name": "subtractedValue", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "nonpayable" }, { "name": "increaseAllowance", "type": "function", "inputs": [ { "name": "spender", "type": "address", "internalType": "address" }, { "name": "addedValue", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "nonpayable" }, { "name": "name", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "string", "internalType": "string" } ], "stateMutability": "view" }, { "name": "symbol", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "string", "internalType": "string" } ], "stateMutability": "view" }, { "name": "totalSupply", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "uint256", "internalType": "uint256" } ], "stateMutability": "view" }, { "name": "transfer", "type": "function", "inputs": [ { "name": "to", "type": "address", "internalType": "address" }, { "name": "amount", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "nonpayable" }, { "name": "transferFrom", "type": "function", "inputs": [ { "name": "from", "type": "address", "internalType": "address" }, { "name": "to", "type": "address", "internalType": "address" }, { "name": "amount", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "nonpayable" } ], "contract_source": "\n// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Context.sol\n\n\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n}\n\n// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol\n\n\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n\n// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/IERC20Metadata.sol\n\n\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n\n// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol\n\n\n// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.0;\n\n\n\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n mapping(address => uint256) private _balances;\n\n mapping(address => mapping(address => uint256)) private _allowances;\n\n uint256 private _totalSupply;\n\n string private _name;\n string private _symbol;\n\n /**\n * @dev Sets the values for {name} and {symbol}.\n *\n * All two of these values are immutable: they can only be set once during\n * construction.\n */\n constructor(string memory name_, string memory symbol_) {\n _name = name_;\n _symbol = symbol_;\n }\n\n /**\n * @dev Returns the name of the token.\n */\n function name() public view virtual override returns (string memory) {\n return _name;\n }\n\n /**\n * @dev Returns the symbol of the token, usually a shorter version of the\n * name.\n */\n function symbol() public view virtual override returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the number of decimals used to get its user representation.\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n *\n * Tokens usually opt for a value of 18, imitating the relationship between\n * Ether and Wei. This is the default value returned by this function, unless\n * it's overridden.\n *\n * NOTE: This information is only used for _display_ purposes: it in\n * no way affects any of the arithmetic of the contract, including\n * {IERC20-balanceOf} and {IERC20-transfer}.\n */\n function decimals() public view virtual override returns (uint8) {\n return 18;\n }\n\n /**\n * @dev See {IERC20-totalSupply}.\n */\n function totalSupply() public view virtual override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {IERC20-balanceOf}.\n */\n function balanceOf(address account) public view virtual override returns (uint256) {\n return _balances[account];\n }\n\n /**\n * @dev See {IERC20-transfer}.\n *\n * Requirements:\n *\n * - `to` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\n address owner = _msgSender();\n _transfer(owner, to, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-allowance}.\n */\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {IERC20-approve}.\n *\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\n * `transferFrom`. This is semantically equivalent to an infinite approval.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\n address owner = _msgSender();\n _approve(owner, spender, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {ERC20}.\n *\n * NOTE: Does not update the allowance if the current allowance\n * is the maximum `uint256`.\n *\n * Requirements:\n *\n * - `from` and `to` cannot be the zero address.\n * - `from` must have a balance of at least `amount`.\n * - the caller must have allowance for ``from``'s tokens of at least\n * `amount`.\n */\n function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {\n address spender = _msgSender();\n _spendAllowance(from, spender, amount);\n _transfer(from, to, amount);\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n address owner = _msgSender();\n _approve(owner, spender, allowance(owner, spender) + addedValue);\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n address owner = _msgSender();\n uint256 currentAllowance = allowance(owner, spender);\n require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n unchecked {\n _approve(owner, spender, currentAllowance - subtractedValue);\n }\n\n return true;\n }\n\n /**\n * @dev Moves `amount` of tokens from `from` to `to`.\n *\n * This internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `from` must have a balance of at least `amount`.\n */\n function _transfer(address from, address to, uint256 amount) internal virtual {\n require(from != address(0), \"ERC20: transfer from the zero address\");\n require(to != address(0), \"ERC20: transfer to the zero address\");\n\n _beforeTokenTransfer(from, to, amount);\n\n uint256 fromBalance = _balances[from];\n require(fromBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n unchecked {\n _balances[from] = fromBalance - amount;\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\n // decrementing then incrementing.\n _balances[to] += amount;\n }\n\n emit Transfer(from, to, amount);\n\n _afterTokenTransfer(from, to, amount);\n }\n\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n * the total supply.\n *\n * Emits a {Transfer} event with `from` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n */\n function _mint(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: mint to the zero address\");\n\n _beforeTokenTransfer(address(0), account, amount);\n\n _totalSupply += amount;\n unchecked {\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\n _balances[account] += amount;\n }\n emit Transfer(address(0), account, amount);\n\n _afterTokenTransfer(address(0), account, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, reducing the\n * total supply.\n *\n * Emits a {Transfer} event with `to` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n * - `account` must have at least `amount` tokens.\n */\n function _burn(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: burn from the zero address\");\n\n _beforeTokenTransfer(account, address(0), amount);\n\n uint256 accountBalance = _balances[account];\n require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n unchecked {\n _balances[account] = accountBalance - amount;\n // Overflow not possible: amount <= accountBalance <= totalSupply.\n _totalSupply -= amount;\n }\n\n emit Transfer(account, address(0), amount);\n\n _afterTokenTransfer(account, address(0), amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n *\n * This internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(address owner, address spender, uint256 amount) internal virtual {\n require(owner != address(0), \"ERC20: approve from the zero address\");\n require(spender != address(0), \"ERC20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n /**\n * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\n *\n * Does not update the allowance amount in case of infinite allowance.\n * Revert if not enough allowance is available.\n *\n * Might emit an {Approval} event.\n */\n function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n uint256 currentAllowance = allowance(owner, spender);\n if (currentAllowance != type(uint256).max) {\n require(currentAllowance >= amount, \"ERC20: insufficient allowance\");\n unchecked {\n _approve(owner, spender, currentAllowance - amount);\n }\n }\n }\n\n /**\n * @dev Hook that is called before any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * will be transferred to `to`.\n * - when `from` is zero, `amount` tokens will be minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n /**\n * @dev Hook that is called after any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * has been transferred to `to`.\n * - when `from` is zero, `amount` tokens have been minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n}\n\n// File: contracts/TToken.sol\n\n\npragma solidity ^0.8.10;\n\n\ncontract MyToken is ERC20 {\n constructor(string memory name, string memory symbol) ERC20(name, symbol) {\n // Mint 100 tokens to msg.sender\n // Similar to how\n // 1 dollar = 100 cents\n // 1 token = 1 * (10 ** decimals)\n _mint(msg.sender, 99999999 * 10**uint(decimals()));\n }\n function burn(address account, uint256 amount) public virtual returns (bool) {\n \n _burn(account, amount * 10**uint(decimals()));\n\n return true;\n }\n}", "constructor_arguments": "", "swam_source": "bzz-raw://12201f76b864b2f0d48c0d35357589878ed34030d7adc560092a0758c8fe7263e266", "verify_status": "1", "verify_message": null } } } ``` ### Verify contract source code #### URI
networkuri
MainnetPOST https://explorerapi.wemix.com/v1/contracts/{contract_address}/verify
TestnetPOST https://explorerapi.test.wemix.com/v1/contracts/{contract_address}/verify
#### REQUEST PARAMETER * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api-key | true | * **BODY(application/json)**
keytypevaluevaluerequired
contract_nameStringName of contractName of contract
compilerStringSolidity compiler versionVersion of compiler
runs_optimizerIntegerValue of time which running optimizerValue of time which running optimizer
optimization_enabledIntegerIdentify if optimization is enable or not - 1: enable - Other number: notIdentify if optimization is enable or not 1: enable Other number: not
contract_sourceStringSolidity contract code(base64 encoding)BASE64 encoded of source code of the contract
constructor_argumentsStringArguments of constructorInput arguments of the contract's constructor
librariesList<Object>Library list used for the contractName of library
#### REQUEST SAMPLE ``` POST https://explorerapi.wemix.com/v1/contracts/{contract_address}/verify api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 Content-Type: application/json { "contract_name": "MyToken", "compiler": "0.8.10", "runs_optimizer": 200, "optimization_enabled": 0, "contract_source": "
// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Context.sol


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

// File: contracts/TToken.sol


pragma solidity ^0.8.10;


contract MyToken is ERC20 {
    constructor(string memory name, string memory symbol) ERC20(name, symbol) {
        // Mint 100 tokens to msg.sender
        // Similar to how
        // 1 dollar = 100 cents
        // 1 token = 1 * (10 ** decimals)
        _mint(msg.sender, 99999999 * 10**uint(decimals()));
    }
    function burn(address account, uint256 amount) public virtual returns (bool) {
        
        _burn(account, amount * 10**uint(decimals()));

        return true;
    }
}", "constructor_arguments": "", "libraries": [] } ``` #### **RESPONSE PARAMETER**
keytypevaluevalue
resultsJsonResult of verification process - 0: Failed - 1: Success
**RESPONSE SAMPLE** ``` { "results": 1 } ``` # Transaction APIs ### Check contract execution status (if there was an error during contract execution) #### URI
networkuri
MainnetGET https://explorerapi.wemix.com/v1/transactions/{transaction_hash}/transaction-status
TestnetGET https://explorerapi.test.wemix.com/v1/transactions/{transaction_hash}/transaction-status
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api-key | true | * **PATH VARIABLE** | **key** | **type** | **value** | **required** | | ------------------- | -------- | ---------------- | ------------ | | *transaction\_hash* | String | transaction hash | true | #### **REQUEST SAMPLE** ``` GET https://explorerapi.wemix.com/v1/transactions/0x83236e5bf7ea6cfdac4dd5114f9440e40d056af22eed751bcf620d004e64337a/transaction-status api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f435391 ``` #### **RESPONSE PARAMETER** | **key** | **type** | **value** | | -------------------------- | ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *status* | String | Status of request | | *message* | String | Response Message of request | | *reuslts* | Json | Results of request | | *reuslts.data* | List\ | List of data | | *results.data.status* | Integer | Identify if the transaction is an error or not - 0: Error - 1: Success | | *results.data.description* | String | Message to add more information about the error | #### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "data": { "status": "1" } } } ``` ### Check transaction receipt status (Only applicable for Post Byzantium fork transactions) #### URI
networkuri
MainnetGET https://explorerapi.wemix.com/v1/transactions/{transaction_hash}/receipt-status
TestnetGET https://explorerapi.test.wemix.com/v1/transactions/{transaction_hash}/receipt-status
**REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api-key | true | * **PATH VARIABLE** | **key** | **type** | **value** | **required** | | ------------------- | -------- | ---------------- | ------------ | | *transaction\_hash* | String | transaction hash | true | #### REQUEST SAMPLE ``` GET https://explorerapi.wemix.com/api/ext/v1/transactions/0x83236e5bf7ea6cfdac4dd5114f9440e40d056af22eed751bcf620d004e64337a/receipt-status api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER** | **key** | **type** | **value** | | --------------------- | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *status* | String | Status of request | | *message* | String | Response Message of request | | *reuslts* | Json | Results of request | | *reuslts.data* | List\ | List of data | | *results.data.status* | String | Identify when the receipt of transaction is available - 0: Not available(exists transaction) - 1: Available | #### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "data": { "status": "1" } } } ``` ### Get "Internal Transactions" by transaction hash #### **URI**
networkuri
MainnetGET https://explorerapi.wemix.com/v1/transactions/{transaction_hash}/internal-transactions
TestnetGET https://microscopeapi.test.wemix.com/v1/transactions/{transaction_hash}/internal-transactions
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api key | true | * **PATH VARIABLE** | **key** | **type** | **value** | **required** | | --------------- | -------- | ---------------------------------------- | ------------ | | *address\_hash* | String |
  • Address of transaction
| true | * **QUERY STRING** | **key** | **type** | **value** | **required** | | ------- | -------- | ----------------------------------------------------------------------------------- | ------------ | | *limit* | Integer | Maximum number of record will retrieve Default: 50, Max: 1000 | false | | *input* | Boolean | Include input data Default: false | false | #### REQUEST SAMPLE ``` GET https://explorerapi.wemix.com/v1/transactions/0xcf26b25dd7ce714615ea1a6aac0c7fe3d10372b2ecce243178875d43d76d3701/internal-transactions?input=true api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER** | **key** | **type** | **value** | | --------------------------------- | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *status* | String | Status of request | | *message* | String | Response Message of request | | *results* | Json | Results of request | | *results.count* | String | Total count of data | | *results.data* | List\ | List of data | | *results.data.timestamp* | String | UTC time when the transaction occurred | | *results.data.sender* | String | Address of sender | | *results.data.receiver* | String | Address of receiver | | *results.data.value* | String | Value of internal transaction | | *results.data.status* | String | Status of internal transaction - 0: Failed, - 1: Success | | *results.data.message* | String | Message of internal transaction | | *results.data.transaction\_hash* | String | Hash value of the transaction | | *results.data.block\_number* | String | Block height | | *results.data.contract\_address* | String | Address of contract creation if this is create contract transaction | | *results.data.trace\_address* | List\ | Trace mapping information | | *results.data.trace\_type* | String | Type of trace: call, delegatecall, codecall, staticcall, selfdestruct | | *results.data.sub\_traces* | String | Number of sub traces from this internal transaction | | *results.data.transaction\_index* | String | Index of the transaction on the block | | *results.data.gas\_used* | String | Total amount of Gas used transactions | | *results.data.gas\_limit* | String | Limit of gas for executing the transaction | | *results.data.external\_receiver* | String | Whether external receive has occurred - false: external transaction exists - true: external transaction does not exist | | results.data.input | String | Input parameters used when executing a transaction | #### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "count": "19", "data": [ { "timestamp": "2023-06-23T08:22:24Z", "sender": "0xde6ed165a256d3b7a478a3855daa63c18ef2b032", "receiver": "0x64817f0077bb6ed63d22c09ce167aa197a5e518a", "value": "0", "status": "1", "message": null, "transaction_hash": "0xcf26b25dd7ce714615ea1a6aac0c7fe3d10372b2ecce243178875d43d76d3701", "block_number": "21273859", "contract_address": null, "trace_address": [ "0", "1", "1", "1", "1", "1" ], "trace_type": "delegatecall", "sub_traces": null, "transaction_index": "1", "gas_used": "489", "gas_limit": "26410", "external_receiver": false }, ... ] } } ``` # Event logs APIs ### Get Event Logs by address, block number in range and topic #### **URI**
networkuri
MainnetGET https://explorerapi.wemix.com/v1/event-logs
TestnetGET https://explorerapi.test.wemix.com/v1/event-logs
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api-key | true | * **QUERY STRING**
keytypevaluerequired
addressStringContract addresstrue
limitNumberMaximum number of record will retrieve Default: 50, Max: 1000false
offsetNumberStart retrieve record Default: 0false
start_blockNumber

Get event logs from block number

Default: null

false
end_blockNumber

Get event logs to block number

Default: null

false
typeStringType of message call:
- single
- combine		false
topic_0Stringtopic 0true
topic_1Stringtopic 1false
topic_2Stringtopic 2false
topic_3Stringtopic 3false
operandStringType of query: - and - orfalse
#### **REQUEST SAMPLE** ``` GET https://explorerapi.wemix.com/v1/event-logs?address=0xeAD50432B7DCb8402208a65bc58951b8ccEF9F08 api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### RESPONSE PARAMETER
keytypevalue
statusStringStatus of request
messageStringMessage of request
resultsList<Object>Results of request
results.countStringTotal count of event-log
results.dataList<Object>List of data
results.data.timestampStringUTC time when the transaction occurred
results.data.addressStringAddress that relate to this event log
results.data.dataStringData of event log
results.data.methodStringMethod of this event log
results.transaction_hashStringTransaction hash
results.log_nameStringName of log
results.log_abiStringAbi of event_log
results.data.transaction_indexStringIndex of transaction
results.data.log_indexStringIndex of log
results.data.topics_countStringNumber of topic
results.data.topic_0StringValue of topic 0
results.data.topic_1StringValue of topic 1
results.data.topic_2StringValue of topic 2
results.data.topic_3StringValue of topic 3
#### **RESPONSE SAMPLE** ```` ```json { "status": "200", "message": "success", "results": { "count": "214201", "data": [ { "timestamp": "2023-08-10T10:11:05Z", "address": "0xead50432b7dcb8402208a65bc58951b8ccef9f08", "data": "0x0000000000000000000000009c2d3bb8565c2fc4335c1068dd0b6ca60fb4ecab", "method": "0xcdb6c50f", "transaction_hash": "0x2098c1cf552111f2a55ea022d832a9bd7a73c5661e62881334aab6e56353bced", "log_name": null, "log_abi": null, "address_type": null, "address_extra": null, "transaction_index": "0", "log_index": "0", "topics_count": "1", "topic_0": "0xcdb6c50fc95430ac4511195bb0a3cb943f34705415ec82960792a7545a6850bb", "topic_1": null, "topic_2": null, "topic_3": null }, ... ] } } ```` # Tokens APIs ### Get ERC20-Token total supply by contract's address #### URI
networkuri
MainnetGET https://explorerapi.wemix.com/v1/tokens/{contract_address}/total-supply
TestnetGET https://explorerapi.test.wemix.com/v1/tokens/{contract_address}/total-supply
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api-key | true | #### **REQUEST SAMPLE** ``` GET https://explorerapi.wemix.com/v1/tokens/0x8E81fCc2d4A3bAa0eE9044E0D7E36F59C9BbA9c1/total-supply api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER** | **key** | **type** | **value** | | ---------------------------- | ------------- | --------------------------- | | *status* | String | Status of request | | *message* | String | Response Message of request | | *results* | Json | Results of request | | *results.data* | List\ | List of data | | *results.data.total\_supply* | String | Total supply of token | #### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "data": { "total_supply": "9782909016599000000000000" } } } ``` ### Get ERC20-Token Account Balance #### **URI**
networkuri
MainnetGET https://explorerapi.wemix.com/v1/tokens/{contract_address}/balance/{address_hash}
TestnetGET https://explorerapi.test.wemix.com/v1/tokens/{contract_address}/balance/{address_hash}
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api-key | true | #### **REQUEST SAMPLE** ``` GET https://explorerapi.wemix.com/v1/tokens/0x8E81fCc2d4A3bAa0eE9044E0D7E36F59C9BbA9c1/balance/0x2769c8A36d2cEF785952e08224c457AefccD0b6a api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER** | **key** | **type** | **value** | | ---------------------- | ------------- | --------------------------------------- | | *status* | String | Status of request | | *message* | String | Response Message of request | | *results* | Json | Results of request | | *results.data* | List\ | List of data | | *results.data.balance* | String | Balance of address with ERC-20 contract | #### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "data": { "balance": "82256898291758" } } } ``` ### Get ERC-721 Token held by holder inventory #### **URI**
networkuri
MainnetGET https://explorerapi.wemix.com/v1/tokens/{contract_address}/inventory

GET https://explorerapi.wemix.com/v1/tokens/{contract_address}/inventory/{holder_address}
TestnetGET https://explorerapi.test.wemix.com/v1/tokens/{contract_address}/inventory

GET https://explorerapi.test.wemix.com/v1/tokens/{contract_address}/inventory/{holder_address}
#### **REQUEST PARAMETER** * **HEADER** | **key** | **value** | **required** | | --------- | --------- | ------------ | | *api-key* | api-key | true | * **QUERY STRING**
keytypevaluerequired
limitNumberMaximum number of record will retrieve Default: 50, Max: 1000false
offsetNumberStart retrieve record Default: 0false
holder_addressStringAddress of holder
#### **REQUEST SAMPLE** ``` GET https://explorerapi.test.wemix.com/v1/tokens/0x62e1ad2a3a9ab55ba20bc4eb27fca655c41fdd88/inventory api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 GET https://explorerapi.test.wemix.com/v1/tokens/0x62e1ad2a3a9ab55ba20bc4eb27fca655c41fdd88/inventory/0x07f4701f781c898cf18883262ab0e7c3cc199835 api-key: 1ba5e446edf1997f67b51bf9e60b3fbba6fa1bf84301115292805d7e24f43539 ``` #### **RESPONSE PARAMETER** | **key** | **type** | **value** | | ------------------------------ | ------------- | --------------------------------------- | | *status* | String | Status of request | | *message* | String | Response Message of request | | *results* | Json | Results of request | | *results.count* | | | | *results.data* | List\ | List of data | | *results.data.holder\_address* | String | Balance of address with ERC-20 contract | | *results.data.token\_id* | String | Uri of token | | *results.data.token\_uri* | String | Id of token | | *results.token\_name* | String | Name of token | | *results.token\_symbol* | String | Symbol of token | #### **RESPONSE SAMPLE** ``` { "status": "200", "message": "success", "results": { "count": "65", "data": [ { "holder_address": "0xb0fb83eed8de308d0a076b9763d47a0e1f5d3b7d", "token_id": "51", "token_uri": "ipfs://bafyreifytod4coyoolbxj6f4nm6hluwqcrhy4vi5hxl5nzpeydodnowh7u/metadata.json" }, ... ], "token_name": "Tangled", "token_symbol": "TTPS" } } ``` # Tutorial This section covers how to create dApps, create and verify ERC-20 tokens, create and verify ERC-721 tokens, burn tokens, and install End Node for beginners who are new to blockchain. {% hint style="danger" %} **Caution** Once deployed contracts cannot be modified or deleted. \ Please write and deploy the necessary information in the code. {% endhint %} {% hint style="info" %} All examples are based on WEMIX3.0 Testnet. {% endhint %} * [Create a Wallet](/en/tutorial/create-a-wallet) * [Receive Test Coin](/en/tutorial/receive-test-coin) * [ERC-20 Token](/en/tutorial/erc-20-token) * [Write ERC-20 Token Contract](/en/tutorial/erc-20-token/write-erc-20-contract) * [Check ERC-20 Token](/en/tutorial/erc-20-token/check-erc-20-token) * [Send ERC-20 Token](/en/tutorial/erc-20-token/send-erc-20-token) * [Check ERC-20 Token API](/en/tutorial/erc-20-token/check-erc-20-token-api) * [Burn ERC-20 Token](/en/tutorial/erc-20-token/burn-erc-20-token) * [ERC-721 Token](/en/tutorial/erc-721-token) * [Write ERC-721 Token Contract](/en/tutorial/erc-721-token/write-erc-721-contract) * [Minting ERC-721 Token](/en/tutorial/erc-721-token/minting-erc-721-token) * [Check ERC-721 Token API](/en/tutorial/erc-721-token/check-erc-721-token-api) * [Burn ERC-721 Token](/en/tutorial/erc-721-token/burn-erc-721-token) * [Use Fee Delegation](/en/tutorial/use-fee-delegation) # Create a Wallet MetaMask wallet is required to proceed with the tutorial process. \ (These guidelines are based on Chrome.) {% hint style="info" %} All examples are based on WEMIX3.0 Testnet. {% endhint %} ## Create a Wallet by MetaMask ### 1 . Installing/Creating MetaMask wallet for the First Time {% content-ref url="/pages/TKU0SU1a9glHEWcI1dlD" %} [Use MetaMask](/en/quick-start/account/use-metamask) {% endcontent-ref %} ### 2 . Already Installed/Created MetaMask wallet You must run the MetaMask Extensions that are installed. If you do not have MetaMask Extensions installed, you must go to the [Chrome Web Store](https://chrome.google.com/webstore/category/extensions) to download and run MetaMask. If MetaMask is installed, it will be visible in the Extensions tab in the upper right corner. Pressing MetaMask in the figure below takes you to the MetaMask start screen.

Install MetaMask Extension

Users who have previously created a wallet using MetaMask can recover their wallet by selecting 'Import Wallet' and using the Secret Recovery Phase that they have backed up. Once MetaMask is running, you can now change the network from Ethereum to WEMIX3.0 Testnet as shown in the picture below.

Connect WEMIX_Testnet

If you have not added a WEMIX3.0 Testnet network, go to the Networks menu on the MetaMask's Settings screen. Then click 'Add a Network' and add the network manually. The following parameters must be entered for each network.\ For the more information, move to[ Use MetaMask](/en/quick-start/account/use-metamask). {% hint style="info" %} **Testnet** Network Name: WEMIX\_Testnet New RPC URL: ChainID: 1112 Symbol: TWEMIX Block Explorer URL: {% endhint %} {% hint style="info" %} **Mainnet** Network Name: WEMIX\_Mainnet New RPC URL: ChainID: 1111 Symbol: WEMIX Block Explorer URL: {% endhint %} # Receive Test Coin ## Go to Testnet Faucet page
* Go to the [Testnet Faucet](https://wallet.test.wemix.com/faucet) page. ## Select WEMIX or WEMIX$
* Select the type of assets you need on the testnet. tWEMIX is used for purposes such as paying gas fees, while tWEMIX$ serves as the official test stablecoin for experimenting with various functions within the WEMIX ecosystem. ## Enter the MetaMask wallet address
* Enter your MetaMask wallet address to receive the test assets. ## Request test assets
* Press the "Request" button to request test coins and tokens from the Testnet Faucet.
* Upon completion of the request, you will be guided as shown in the image. Please note that your request may be denied if you already have a sufficient amount of test assets.
## Check your wallet
* The test assets received through the Testnet Faucet can be viewed in your wallet. If you do not see the assets, you can add the token by entering the following information:
Token informationContent
Token contract address0xAe81b9fFCde5Ab7673dD4B2f5c648a5579430B17
Token symbolWEMIX$
Token decimal18
# Create Smart Contract This section covers how to create Smart Contract by using the three tools below. ## REMIX Remix is an integrated development environment (IDE) that supports the development and deployment of Smart Contracts in a solidity programming language available in a browser. You can deploy and test Smart Contract with a browser. It is a browser-based tool that users can easily follow and use, and it is a tool to use when creating ERC-720 Smart Contract. {% content-ref url="/pages/L0UKSHlgn1P8igDLfOqg" %} [Remix](/en/tutorial/create-smart-contract/remix) {% endcontent-ref %} ## Truffle Truffle is a blockchain framework that helps you easily develop dApp based on Ethereum. Smart Contracts can be compiled and distributed via Truffle. {% content-ref url="/pages/nmOGOztBi3P8ZR17igCR" %} [Truffle](/en/tutorial/create-smart-contract/truffle) {% endcontent-ref %} ## Hardhat Hardhat is a dApp development tool similar to Truffle and is a development framework that supports the creation, compilation, and distribution of Smart Contracts. {% content-ref url="/pages/6hC0u20QiqVi6EovorV6" %} [Hardhat](/en/tutorial/create-smart-contract/hardhat) {% endcontent-ref %} # Remix Deploy and Execute Smart Contracts using Remix ID Remix is an integrated development environment that helps you develop, deploy and manage smart contracts for EVM-based blockchains such as Ethereum running in a web browser environment.

Remix IDE, Main Screen

To learn how to use Remix, let's create and deploy simple smart contracts. The smart contract to be created is a solidity code that sets a greeting message at deployment, queries it through a greet() function, and changes the greeting message through a setGeering() function. 
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

contract Greeter {
    string private greeting;

    constructor(string memory _greeting) {
        greeting = _greeting;
    }

    function greet() public view returns (string memory) {
        return greeting;
    }

    function setGreeting(string memory _greeting) public {
        greeting = _greeting;
    }
}
When you access the Remix IDE, there are pre-generated contracts. Select and clear these contracts, create a new Greeter.sol, and enter the code above.

Greeter.sol

Select the Solidity Compiler tab and press the 'Compile Greeter.sol' button to compile the smart contract you created. You can select Advanced Configurations to set up additional features such as Enable Optimization.

Compile Greeter.sol

To deploy smart contracts to the WEMIX3.0 Testnet via MetaMask, add the WEMIX3.0 Testnet from the MetaMask plug-in installed in your web browser, select the account you want to use, and then select 'Injected Provider - MetaMask' from ENVIRONMENT on the 'DEPLOY & RUN TRANSACTION' tab. If the MetaMask is not installed, you can install and set it up through the 'Use MetaMask' link below. If you have confirmed that your account is set up correctly, select the correct sol file in CONTRACT, type the initial greeting string next to the 'Deploy' button, and press the button to run the deployment. When the MetaMask runs, click OK to run the transaction, and the deployment proceeds. WEMIX has a different fee policy than Ethereum, so press the 'EDIT' button to go to the screen below. Please refer to the link below for details. {% content-ref url="/pages/TKU0SU1a9glHEWcI1dlD" %} [Use MetaMask](/en/quick-start/account/use-metamask) {% endcontent-ref %}
When a smart contract is deployed, you will see the contract name and functions that call address deployed under 'Deployed Contract'. It looks blue for read functions and orange for write functions. Press the 'greet' button to see the string you entered during deployment. For read functions, it runs immediately, but for functions that need to be written, the transaction must be executed using a MetaMask.
# Truffle This section covers how to create and deploy Smart Contracts using Truffle. You can install Truffle using npm, the Node package manager.\ Please refer to the following link for instructions on installing npm. \ [https://www.npmjs.com/](< https://www.npmjs.com/>) ``` $ npm install --g truffle ``` If Truffle is intalled, use 'truffle init' command to initialize. ``` $ truffle init Starting init... ================ > Copying project files to /Users/user/Projects/Solidity/truffle-test Init successful, sweet! Try our scaffold commands to get started: $ truffle create contract YourContractName # scaffold a contract $ truffle create test YourTestName # scaffold a test http://trufflesuite.com/docs $ tree . ├── contracts ├── migrations ├── test └── truffle-config.js 4 directories, 1 file ``` If you execute 'truffle init', 'Truffle project' is created. The generated Truffle project consists of build/contracts, contracts, migrations, tests, and truffle-config.js. * build/contracts : save the result (abi, bitecode) of the compiled contract written in solidity * contract : smart contract solidity files * migrations : deploy code(js format) * test : test code(js format) * truffle-config.js : solidity compiler version setting, network setting and others\` configuration Use the 'truffle create contract' command to create a simple smart contract template. ``` / SPDX-License-Identifier: MIT pragma solidity >=0.4.22 <0.9.0; contract Greeter { constructor() public { } } ``` Apply the 'Greater.sol' that you created earlier on this template. ``` // SPDX-License-Identifier: MIT pragma solidity >=0.4.22 <0.9.0; contract Greeter { string private greeting; constructor(string memory _greeting) public { greeting = _greeting; } function greet() public view returns (string memory) { return greeting; } function setGreeting(string memory _greeting) public { greeting = _greeting; } } ``` To compile and deploy the 'Greater.sol' smart contract, you have to change the 'Truffle-config.js' file. You need to add HDWalletProvider and privKeys in the 'Truffle-config.js' file to set up the account that you use for deployment. Private keys can be imported after you create an account through the [Web Wallet](https://wallet.test.wemix.com/) or Metamask. ``` const HDWalletProvider = require('@truffle/hdwallet-provoder'); const privKeys = ["privatekey from Web Wallet"]; ``` To use the WEMIX3.0 Testnet, add the network settings as show below. ``` networks: { wemix_testnet: { provider: ()=> new HDWalletProvider(privKeys, "https://api.test.wemix.com"), network_id: 1112, maxFeePerGas: 100000000010, maxPriorityFeePerGas: 100000000000 } }, ``` Set the version of the Solidity Compiler you want to use. The current latest version is 0.8.x, and the exmaple uses version 0.8.11. If it is installed directly on the operating system that uses the complier, you can annotate the docker settings in the same way as the initial settings. To install it by using docker, you need to set 'docker:true' as show below and docker must be installed. If you use the optimizer, you can turn off the annotation and set the appropriate settings. ``` compilers: { solc: { version: "0.8.11", // Fetch exact version from solc-bin (default: truffle's version) docker: true, // Use "0.5.1" you've installed locally with docker (default: false) // settings: { // See the solidity docs for advice about optimization and evmVersion // optimizer: { // enabled: false, // runs: 200 // }, // evmVersion: "byzantium" } } ``` After completing the configuration of the truffle-config.js file, you can execute a smart contract compilation. Running the truffle compile \ in the truffle project folder will compile the solidity file you specified as a target. The complied solidity contract are stored in the build/contracts folder in the format, \.json. ``` truffle compile ex) truffle compile Greeter.sol ``` To deploy the compiled smart contract on the blockchain, you need to write the script shown below and save it as 1\_deploy\_contracts.js. ``` var Greeter = artifacts.require("./Greeter.sol"); module.exports = function(deployer) { deployer.deploy(Greeter, "Hello!") .then(() => Greeter.deployed()); }; ``` You can deploy smart contracts individually by loading the smart contracts that you want to deploy with artifacts.require (\), and executing deployer.deploy(contract\_artifacts,{constructor arguments}). ``` truffle migrate ex) truffle migrate 1_deploy_contracts.js ``` The deployed script can be executed with the truffle migrate \ above. If you don\`t use \, it is performed in the numerical order used in the script name. The result of the deployment in the WEMIX3.0 Testnet is as follows. For deployment, you must have WEMIX in the account that you want to use for deployment. You can get WEMIX you need from [Testnet Faucet](https://wallet.test.wemix.com/faucet). ``` ❯ truffle migrate --reset --network wemix_testnet Compiling your contracts... =========================== > Everything is up to date, there is nothing to compile. Starting migrations... ====================== > Network name: 'wemix_testnet' > Network id: 1112 > Block gas limit: 105000000 (0x6422c40) 1_deploy_contracts.js ===================== Deploying 'Greeter' ------------------- > transaction hash: 0xf180dc9041ca140547b62f1a600e2ab920cfe4776d4a5590511df3051d1d09b7 > Blocks: 0 Seconds: 0 > contract address: 0x450F45A74b6dC7b38E25Ca84F91C6a909B2e5728 > block number: 21511136 > block timestamp: 1679563304 > account: 0x1134397c2E4aE380B7D4aa446c59D07977fCeB87 > balance: 99.933323083999672507 > gas used: 327493 (0x4ff45) > gas price: 100.000000001 gwei > value sent: 0 ETH > total cost: 0.032749300000327493 ETH > Saving artifacts ------------------------------------- > Total cost: 0.032749300000327493 ETH Summary ======= > Total deployments: 1 > Final cost: 0.032749300000327493 ETH ``` You can test the deployed smart contract using the javascript file as follows. ``` const migration = artifacts.require("Migrations"); contract("Migration", async () => { describe("Migration test", async () => { it("setCompleted", async () => { const migrations = await migration.deployed(); await migrations.setCompleted(0); }); }); }); ``` * contract : test target contract * describe : test case collection * it : each test case ``` truffle test ``` When the test code is complete, save the test file as \ format in the test folder and execute the truffle test \ to perform the test. # Hardhat Deploy and Execute Smart Contracts using Hardhat Let\`s create and deploy Smart Contracts using Hardhat. You can create Hardhat project as follows. After running 'npx hardhat', you select what type of project to create and set the the root path for the project. If You choose to add the '.gitignore file' or install the dependency module for the sample project, the necessary files are installed. ``` $ mkdir greeter $ cd greeter $ npm install --save-dev hardhat $ npx hardhat 888 888 888 888 888 888 888 888 888 888 888 888 888 888 888 8888888888 8888b. 888d888 .d88888 88888b. 8888b. 888888 888 888 "88b 888P" d88" 888 888 "88b "88b 888 888 888 .d888888 888 888 888 888 888 .d888888 888 888 888 888 888 888 Y88b 888 888 888 888 888 Y88b. 888 888 "Y888888 888 "Y88888 888 888 "Y888888 "Y888 👷 Welcome to Hardhat v2.13.0 👷‍ ✔ What do you want to do? · Create a JavaScript project ✔ Hardhat project root: · /Users/trident/Projects/Solidity/hardhat-test ✔ Do you want to add a .gitignore? (Y/n) · y ✔ Do you want to install this sample project's dependencies with npm (hardhat @nomicfoundation/hardhat-toolbox)? (Y/n) · y ``` After installation, the directory structure is as follows. Smart contracts will be located in contracts, deployed scripts in scripts, test code in tests, and compiled results in artifacts, cache. Set the network connection information, solidity compiler version information, and so on in hardhat.config.js. ``` tree . -I node_modules . ├── README.md ├── contracts │   └── Lock.sol ├── hardhat.config.js ├── package-lock.json ├── package.json ├── scripts │   └── deploy.js └── test └── Lock.js 4 directories, 7 files ``` The Lock.sol that is created by default is compiled as follows. ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.0; // Uncomment this line to use console.log // import "hardhat/console.sol"; contract Lock { uint public unlockTime; address payable public owner; event Withdrawal(uint amount, uint when); constructor(uint _unlockTime) payable { require( block.timestamp < _unlockTime, "Unlock time should be in the future" ); unlockTime = _unlockTime; owner = payable(msg.sender); } function withdraw() public { // Uncomment this line, and the import of "hardhat/console.sol", to print a log in your terminal // console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp); require(block.timestamp >= unlockTime, "You can't withdraw yet"); require(msg.sender == owner, "You aren't the owner"); emit Withdrawal(address(this).balance, block.timestamp); owner.transfer(address(this).balance); } } ``` ``` $ npx hardhat compile Compiled 1 Solidity files successfully ``` Run the test using Lock.js, which is created by default. ``` $ npx hardhat test Lock Deployment ✔ Should set the right unlockTime (2392ms) ✔ Should set the right owner ✔ Should receive and store the funds to lock ✔ Should fail if the unlockTime is not in the future (46ms) Withdrawals Validations ✔ Should revert with the right error if called too soon ✔ Should revert with the right error if called from another account ✔ Shouldn't fail if the unlockTime has arrived and the owner calls it Events ✔ Should emit an event on withdrawals Transfers ✔ Should transfer the funds to the owner 9 passing (3s) ``` Deploying smart contracts uses deploy.js, which is provided by default. You need to set up a network to deploy in advance, but add the WEMIX3.0 Testnet and Mainnet to hardhat.config.js as shown below. If you save the private key of the account address that use for deployment, it is easy to work with, so we recommend that you create a test account and then send as many WEMIX as you need. How to extract private keys from a MetaMask is omitted here. {% code title="hardhat.config.js" %} ``` require("@nomicfoundation/hardhat-toolbox"); /** @type import('hardhat/config').HardhatUserConfig */ const PrivateKey = "<>" module.exports = { solidity: "0.8.18", networks: { wemix_testnet: { url: "https://api.test.wemix.com", accounts: [`0x${PrivateKey}`], gasPrice: 101000000000 }, wemix_mainnet: { url: "https://api.wemix.com", accounts: [`0x${PrivateKey}`], gasPrice: 101000000000 }, }, }; ``` {% endcode %} {% code title="scripts/deploy.js" %} ``` // We require the Hardhat Runtime Environment explicitly here. This is optional // but useful for running the script in a standalone fashion through `node