- Integrated payments to roll out globally in 190 countries, following a successful test in North America and Canada, , - The new release is designed to tackle last mile payments amid 87% content creators reporting late or missed invoices, , - <strong>WeTransfer</strong> to waive additional platform fees for ...

WeTransfer unveils payments to help creatives earn money | WebWire

Canadian chef, restaurateur, and executive producer Matty Matheson has now come together with WeTransfer for a first-of-its-kind free digital cookbook. Titled Cookin’ Somethin f

WeTransfer and Matty Matheson Come Together for First-Of-Its-Kind Free Digital Cookbook

Matty Matheson, celebrity chef and star of FX's restaurant dramedy 'The Bear,' has released a free digital cookbook via WeTransfer.

‘The Bear’ Star Matty Matheson Drops Free Digital Cookbook, ‘Cookin’ Somethin’ for College’ (EXCLUSIVE)

SINGAPORE: The Inland Revenue Authority of Singapore (IRAS) has issued a warning to the public... The post IRAS warns public of scammers sending fake tax notices appeared first on The Independent Sing

IRAS warns public of scammers sending fake tax notices

Impact A.M. ESG Awards Nomination Use this form to complete your nomination if you are submitting a written application. But if you are submitting a video application please send this via WeTransfer to events@cityam.

Nomination Form For Impact A.M. Awards

SINGAPORE – Do not click on a URL link purportedly from the Inland Revenue Authority of Singapore (Iras) claiming that your property tax notice is ready for viewing via WeTransfer, the government agency said in an advisory on Thursday. “This is a new ...

Beware of phishing e-mails asking taxpayers to view property tax notices via WeTransfer: Iras

NEW YORK - 11 October, 2023 - WeTransfer, the most creative platform for sharing ideas, and co—matter, a Berlin-based research and strategy studio, release a new piece of research on internet culture called Networked Reality: A creative’s guide to ...

WeTransfer launches Networked Reality memo

We hear from Deliveroo’s in-house agency about how they created a new identity fit for a global brand, and why its existing logo and teal colour weren’t up for discussion

Backstage Sessions: reflections and advice from three photographic greats

Brainlabs Founder Daniel Gilbert will continue to lead as Global CEO, and Stephen Allan will remain full-time Executive Chairman. Falfurrias Capital Partners' Alexander Jutkowitz, Geordie Pierson, and Joe Price, as well as the Ad Council's Lisa Sherman will join the company board.

Falfurrias Capital Partners Announces Growth Investment in Brainlabs

WeTransfer

wetransfer

The Power of Market Disruption: How to Detect Fraud With Graph Data

Fiber Network: A Lightning Network Based on CKB

Оптавалаконная сетка: маланкавая сетка на аснове CKB

Red de fibra: una red Lightning basada en CKB

شبکه فیبر: یک شبکه رعد و برق مبتنی بر CKB

Rede de fibra: unha rede Lightning baseada en CKB

Fiber Network: Lightning mreža temeljena na CKB-u

ファイバーネットワーク: CKB に基づくライトニングネットワーク

Fiber Network: Mheni Network Yakavakirwa paCKB

Shabakadda Fiber: Shabakad hillaac ah oo ku salaysan CKB

Фибер мрежа: Лигхтнинг мрежа заснована на ЦКБ

Tolali tarmoq: CKB-ga asoslangan chaqmoq tarmog'i

Mạng cáp quang: Mạng Lightning dựa trên CKB

Inethiwekhi yeFayibha: Inethiwekhi yoMbane esekwe kwi-CKB

This paper is under CC 4.0 license. available on arxiv Authors: (1) Zhe Liu, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China; (2) Chunyang Chen, Monash University, Melbourne, Australia; (3) Junjie Wang, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China & Corresponding author; (4) Mengzhuo Chen, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China; (5) Boyu Wu, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China; (6) Zhilin Tian, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China; (7) Yuekai Huang, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China; (8) Jun Hu, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China; (9) Qing Wang, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China & Corresponding author. Table of Links Abstract and Introduction Motivational Study and Background Approach Experiment Design Results and Analysis Discussion and Threats to Validity Related Work Conclusion and References 3 APPROACH This paper aims at automatically generating a batch of unusual text inputs which can possibly make the mobile apps crash. The common practice might directly produce the target inputs with LLM as existing studies in valid input generation [44] and fuzzing deep learning libraries [20, 21]. Yet, this would be quite inefficient for our task, because each interaction with the LLM requires a few seconds waiting for the response and consumes lots of energy. Instead, this paper proposes to produce the test generators (a code snippet) with LLM, each of which can generate a batch of unusual text inputs under the same mutation rule (e.g., insert special characters into a string), as demonstrated in Figure 4 ⑤. To achieve this, we propose InputBlaster which leverages LLM to produce the test generators together with the mutation rules which serve as the reasoning chains for boosting the performance, and each test generator then automatically generates a batch of unusual text inputs, as shown in Figure 3. In detail, given a GUI page with text input widgets and its corresponding view hierarchy file, we first leverage LLM to generate the valid text input which can pass the GUI page (Sec 3.1). We then leverage LLM to produce the test generator which can generate a batch of unusual text inputs, and simultaneously we also ask the LLM to output the mutation rule which serves as the reasoning chain for guiding the LLM in making the effective mutations from valid inputs (Sec 3.2). To further boost the performance, we utilize the in-context learning schema to provide useful examples when querying the LLM, from online issue reports and historical running records (Sec 3.3). 3.1 Prompt Generation for Valid Input InputBlaster first leverages LLM to generate the valid input which will serve as the target towards which the following mutation can be conducted. The context information relates to the input widgets and its belonged GUI page can provide important clues about what the valid input should be, therefore we input this information into LLM (in Section 3.1.1). In addition, we also include the dynamic feedback information when interacting with the input widgets (in Section 3.1.2), and the constraint categories we summarized in the previous section (in Section 3.1.3) to improve the performance. Furthermore, besides the valid text input, we also ask LLM to output its inferred constraints for generating the valid input which will facilitate the approach to generating the mutation rules in the next section. We summarize all the extracted information with examples in Table 1. The context information is extracted from the view hierarchy file, which is easily obtained by automated GUI testing tools [26, 48, 49, 61]. As shown in Table 1, we extract the text-related field of the input widget which indicates how the valid input should be. In detail, we extract the “hint text”, “resource id”, and ‘text’ fields of the input widget, and utilize the first non-empty one among the above three fields. 3.1.1 Context Extraction. We also extract the activity name of the GUI page and the mobile app name, and this global context further helps refine the understanding of the input widget. In addition, we extract the local context of the input widget (i.e., from nearby widgets) to provide thorough viewpoints and help clarify the meaning of the widget. The candidate information source includes the parent node widgets, the leaf node widget, widgets in the same horizontal axis, and fragment of the current GUI page. For each information source, we extract the “text” field (if it is empty, use the “resource-id” field), and concatenate them into the natural-language description with the separator (‘;’). When one inputs an incorrect text into the app, there are some feedbacks (i.e., dynamic hints) related to the inputs, e.g., the app may alter the users that the password should contain letters and digits. The dynamic hint can further help LLM understand what the valid input should look like. 3.1.2 Dynamic Hint Extraction. We extract the dynamic hints via differential analysis which compares the differences of the GUI page before and after inputting the text, and extracts the text field of the newly emerged widgets (e.g., a popup window) in the later GUI page, with examples shown in Figure 2. We also record the text input which makes the dynamic hint happens, which can help the LLM to understand the reason behind it. Our pilot study in Section 2.1.2 summarizes the categories of constraints within and among the widgets. The information can provide direct guidance for the LLM in generating the valid inputs, for example, the constraint explicitly requires the input should be pure text (without special characters). We provide this list of all candidate constraints described in natural language as in Section 2.1.2 to the LLM. 3.1.3 Candidate Constraints Preparation. With the extracted information, we use three kinds of information to generate prompts for inputting into the LLM, as shown in Table 1. Generally speaking, it first provides the context information and the dynamic hints (if any) of the input widgets, followed by the candidate constraints, and then queries the LLM for the valid input. Due to the robustness of LLM, the generated prompt sentence does not need to fully follow the grammar. 3.1.4 Prompt Generation. After inputting the prompt, the LLM will return its recommended valid text input and its inferred constraints, as demonstrated in Figure 4 ②. We then input it into the widget, and check whether it can make the app transfer to the new GUI page (i.e., valid input). If the app fails to transfer, we iterate the process until the valid input is generated. 3.2 Prompt Generation for Test Generator with Mutation Rule Based on the valid input in the previous section, InputBlaster then leverages LLM to produce the test generator together with the mutation rule. As demonstrated in Figure 4 ⑤, the test generator is a code snippet that can generate a batch of unusual inputs, while the mutation rule is the natural language described operation for mutating the valid inputs which automatically output by LLM based on our prompt and serves as the reasoning chain for producing the test generator. Note that the mutation rule here is output by LLM. Each time when a test generator is produced, we can obtain a batch of automatically generated unusual text inputs, and will input them into the text widgets to check whether they have successfully made the mobile app crash. This test execution feedback (in Section 3.2.2) will be incorporated in the prompt for querying the LLM which can enable it more familiar with how the mutation works and potentially produce more diversified outcomes. We also include the inferred constraints in the previous section in the prompt (in Section 3.2.1), since the natural language described explanation would facilitate the LLM in producing effective mutation rules, for example, the inferred constraint is that the input should be in pure text (without special characters) and the LLM would try to insert certain characters to violate the constraint. We have obtained the inferred constraints and valid input from the output of the LLM in the previous section, here we extract this information from the output message and will input it into the LLM in this section. We design a flexible keyword matching method to automatically extract the description between the terms like ‘constraints’ and ‘the input’ and treat it as the inferred constraints, and extract the description after the terms like ‘input is’ and treat it as the valid input, as demonstrated in Figure 4 ②. 3.2.1 Inferred Constraints and Valid Input Extraction. After generating the unusual text inputs, we input them into the mobile app and check whether they can successfully trigger the app crash. This test execution information will be inputted into the LLM to generate more effective and diversified text inputs. We use the real buggy text inputs and the other unusual inputs (which don’t trigger bugs) to prompt LLM in the follow-up generation. The former can remind the LLM to avoid generating duplicate ones, while the latter aims at telling the LLM to consider other mutation rules. 3.2.2 Test Execution Feedback Extraction. Besides, we also associate the mutation rules with the text input to enable the LLM to better capture its semantic meaning. As shown in Figure 4 ⑤, we extract the content between the keywords “Mutation rule” and “Test generator” as mutation rules. With the extracted information, we design linguistic patterns of the prompt for generating the test generator and mutation rules. As shown in Figure 4 ④, the prompt includes four kinds of information, namely inferred constraints, valid input, text execution feedback, and question. The first three kinds of information are mainly based on the extracted information as described above, and we also add some background illustrations to let the LLM better understand the task, like the inferred constraint in Figure 4 ④. For the question, we first ask the LLM to generate the mutation rule for the valid input, then let it produce a test generator following the mutation rule. Due to the robustness of LLM, the generated prompt sentence does not need to follow the grammar completely. 3.2.3 Prompt Generation. 3.3 Enriching Prompt with Examples It is usually difficult for LLM to perform well on domain-specific tasks as ours, and a common practice would be employing the in-context learning schema to boost the performance. It provides the LLM with examples to demonstrate what the instruction is, which enables the LLM better understand the task. Following the schema, along with the prompt for the test generator as described in Section 3.2, we additionally provide the LLM with examples of the unusual inputs. To achieve this, we first build a basic example dataset of buggy inputs (which truly trigger the crash) from the issue reports of open-source mobile apps, and continuously enlarge it with the running records during the testing process (in Section 3.3.1). Based on the example dataset, we design a retrieval-based example selection method (in Section 3.3.2) to choose the most suitable examples in terms of an input widget, which further enables the LLM to learn with pertinence. We collect the buggy text inputs from GitHub and continuously build an example dataset that serves as the basis for in-context learning. For each data instance, as demonstrated in 4 ③, it records the buggy text inputs and the mutation rules which facilitate the LLM understanding of how the buggy inputs come from. It also includes the context information of the input widgets which provides the background information of the buggy inputs, and enables us to select the most suitable examples when querying the LLM. 3.3.1 Example Dataset Construction. First, we automatically crawl the issue reports and pull  requests from the Android mobile apps in GitHub (updated before September 2022). Then we use keyword matching to filter these related to the text inputs (e.g., EditText) and have triggered crashes. Following that, we then employ manual checking to further determine whether there is a crash triggered by the buggy text inputs by running the app. In this way, we obtain 50 unusual inputs and store them in the example dataset (There is no overlap with the evaluation datasets.). We then extract the context information of the input widget with the method in Section 3.1.1, and store it together with the unusual input. Note that, since these buggy inputs don’t associate with the mutation rules, we set them as null. Mining buggy text inputs from GitHub. We enrich the example dataset with the newly emerged unusual text inputs which truly trigger bugs during InputBlaster runs on Enlarging the dataset with buggy text inputs during testing. various apps. Specifically, for each generated unusual text input, after running it in the mobile apps, we put the ones which trigger crashes into the example dataset. We also add their associated mutation rules generated by the LLM, as well as the context information extracted in Section 3.1.1. Examples can provide intuitive guidance to the LLM in accomplishing a task, yet excessive examples might mislead the LLM and cause the performance to decline. Therefore, we design a retrieval based example selection method to choose the most suitable examples (i.e., most similar to the input widgets) for LLM. 3.3.2 Retrieval-based Example Selection and In-context Learning. In detail, the similarity comparison is based on the context information of the input widgets. We use Word2Vec (Lightweight word embedding method) [50] to encode the context information of each input widget into a 300-dimensional sentence embedding, and calculate the cosine similarity between the input widget and each data instance in the example dataset. We choose the top-K data instance with the highest similarity score, and set K as 5 empirically. The selected data instances (i.e., examples) will be provided to the LLM in the format of context information, mutation rule, and buggy text input, as demonstrated in Figure 4 ③. 3.4 Implementation We implement InputBlaster based on the ChatGPT which is released on the OpenAI website[3]. It obtains the view hierarchy file of the current GUI page through UIAutomator [65] to extract context information of the input widgets. InputBlaster can be integrated by replacing the text input generation module of the automated GUI testing tool, which automatically extracts the context information and generates the unusual inputs. [3] https://beta.openai.com/docs/models/chatgpt

Leveraging LLMs for Generation of Unusual Text Inputs in Mobile App Tests: Approach

This is a continuation of my article on CBDC (Central Bank Digital Currency) from the “Now You Understand” series. , I looked at what a CBDC is, and how this form of digital currency can be used, how it differs from stablecoins, and why private rather than public blockchains are used to implement CBDC solutions. In the first part You can read it here ⬇️ https://hackernoon.com/now-you-understand-central-bank-digital-currency-cbdc-explanation-and-usage-part-i?embedable=true In this part, I will look at what solutions are being used in different states to implement CBDCs, take a closer look at the Brazilian DREX case study, and follow the dynamics of CBDC implementation around the world. Enjoy reading! What solutions are countries using to implement CBDC? To implement CBDC, central banks will need a blockchain infrastructure. In this section, we’ll discuss the technical characteristics of the most common blockchain platforms for implementing digital currencies. During the research for this article, I conducted a thorough analysis of different solutions and platforms. My findings show that Based on the data and sources studied, it is evident that a few select blockchain platforms will be used prominently in various countries for CBDC implementation. Hyperledger Blockchain is emerging as a dominant tool in this domain. In addition, notable platforms such as Quorum and R3 Corda are actively used in significant projects (e.g., Dunbar, Jura). The selection of these platforms is driven by their popularity and track record, particularly in facilitating CBDC implementation. Hyperledger Besu Besu is an EVM-compatible blockchain platform with additional functionality to provide privacy capabilities. It supports private smart contracts and transactions. In the corporate sector, this is a must-have for technology adoption at all stages. Privacy became possible here due to a separate set of nodes that is responsible for encrypting private transactions. The Besu client does not include built-in private key management. External tools, such as Ethereum-compatible wallets, are used to manage private keys and sign transactions. This provides a greater level of security and flexibility. Besu is a permissioned network. It allows you to list approved accounts and deny all transactions from accounts that are not on the list. It allows you to determine which nodes can connect and participate in the network and which cannot. This is also achieved by adding nodes to the list of approved nodes, if a node is not on this list it is denied access to the network. This increases overall security and access control as well. Since only selected members can participate in the network, it significantly increases throughput. Hyperledger Fabric Fabric is a private blockchain platform designed for enterprise use, with a focus on privacy. It was initially developed by IBM and was transferred to the Linux Foundation in 2015. Unlike Besu, Fabric is not an EVM-compliant platform and has a different architecture, smart contracts are called chaincodes which are developed using , JS/TS, and . Go Java Fabric architecture includes a special type of node that is responsible for transaction processing, computation, and state management, they are called endorsers/committers. Another type of node called Orderers is responsible for reaching consensus, sequencing transactions, and placing them into blocks. For a higher level of privacy, another element called channels is implemented. Channels are represented as subnets in which only participating nodes have access to chain codes and transactions, while participants outside the channel are unaware of their existence, providing a high level of privacy and confidentiality. This functionality can be especially useful when there is a requirement to separate several directions and isolate them from each other. In Fabric, private transactions are also possible through direct P2P communications. In this scenario, only the hashes of the input data of the transaction are shared with the Orderers nodes and written to the ledger along with the transaction. Fabric supports pluggable consensus mechanisms, which means there is flexibility to choose the most suitable option for specific challenges and requirements. As Fabris is a private solution, this also means that a node in this network can only be started with the permission of authorized entities, which restricts the network participants. Hyperledger Iroha Launched in 2019, Iroha is a private blockchain platform that is also focused on enterprise use. The difference is that it has a simpler design and is easier to integrate thanks to its modular architecture. It also supports smart contracts. This platform is primarily performance-oriented with its own fault-tolerant consensus algorithm under the hood. It provides high throughput and low delay in transaction processing. A node can only be launched on this network with the permission of authorized entities. On this platform, Cambodia launched Bakong, a project controlled by the Central Bank of Cambodia, which is designed for mobile payments and banking. There was a problem with the coverage of banking services, and this project solved that problem by allowing all citizens to open an account and make cashless and secure payments. And for banks, it opened up the possibility of interbank transfers at a lower cost. This project is not entirely a CBDC, although it is administered by the Central Bank, but rather a tokenized deposit system. Quorum Quorum is an enterprise blockchain platform that is based on Ethereum but extended with functionality customized to the specific requirements of corporate clients. The platform was founded by J. P. Morgan Chase in 2016. In 2020, Consensys bought Quorum and now supports and develops the platform. The special feature of this platform is that it has a built-in privacy functionality, which opens up opportunities for corporate use. For example, there is the option for private transactions. This is very important compared to an open network because when we transfer money, we don't want anyone to know about it. The control of this platform is based on consensus mechanisms which assume that only selected participants are allowed to participate and maintain control of the network. For example, governance may be centralized at the Central Bank. Such a mechanism not only consolidates power in the system, but also provides a number of benefits, such as increased throughput and transaction speed. This is achieved by the fact that the number of nodes to reach a consensus between is minimal and limited. There is no need to wait for a large number of participants to agree. Unlike Ethereum, Quorum has zero gas costs, which means you don't need to pay for gas for transactions. As Quorum is based on Ethereum, it supports smart contracts in Solidity. Smart contracts open up the possibility of creating their applications, e.g. by commercial banks with permission from central banks. Smart contracts in Quorum can be as private as transactions. Similarly to a regular contract, for confidentiality reasons, it is necessary that they are not available to anyone. When we buy or sell a property, we don't want anyone to know the terms of the transaction and its participants. Smart contracts are deployed on the blockchain and are always available for interaction, the code is executed when called, so there is no need for a third party. For example, when we make a transaction, we have to wait for a third party, such as a bank, to execute it. In the case of smart contracts, we have no such need because everything is done by the executable code. Such interaction is always available 24/7, unlike standard organizations. They are also an excellent way to tokenize assets or access rights. Corda Corda platform is based on distributed ledger technology (DLT), but it is not a blockchain. That's why it's different from all the others. This platform is fully focused on privacy and by default all transactions are private. It does not have a global shared ledger and only supports transactions in which only counterparties are involved. Transactions are only related to bilateral or multilateral agreements between counterparties. Here each node maintains its own register of transactions, where they are linked to each other and complete in real time since there is no blockchain. But in this case the issue of double spending and others arise. Here this is solved by installing a notary which is a third party and controls the validity of transactions. Notary is a separate set of nodes and the level of decentralization is directly related to Notary. The model is based on strict confidentiality and each node must prove that it has been validly connected to the network using a certificate from authorized members. The signature capability here exists only on the nodes. Each application here exists only in the nodes of the network as well as the ability to sign transactions. This is significantly different from the standard Ethereum model where signature control is maintained by the client wallets. In fact, they simply run the process and control its execution. Here these applications are called CorDapp. : Drex (Digital Brazilian Real) Example of a CBDC implementation Brazil has launched its own CBDC called Drex (Digital Brazilian Real) in pilot mode on the Hyperledger Besu platform. As we know, it is an EVM-compliant blockchain, which means that it supports smart contracts in Solidity. The control architecture of the network is structured in such a way that it is centralized at the Central Bank and therefore managed completely privately. A node can only launch on this network with the permission of the Central Bank. End users can only have custodial wallets managed by an organization that has been authorized by the Central Bank, such as a commercial bank. There are retail and wholesale forms of CBDC. The wholesale form is intended only for high-volume transactions, such as between banks, cooperatives and possibly with the participation of large corporations. The retail form is designed for payments and transfers between individuals and businesses of any size and can be used for everyday financial transactions in any value range. In this implementation, CBDCs are smart contracts on Solidity ERC-20 standards, there are two main ones: RealDigital and RealTokenizado. The main token is RealDigital, which is controlled by the central bank. Other participants in the system, such as commercial banks and other financial institutions control their own token, RealTokenizado, which actually extends the RealDigital contract and its functionality. RealTokenizado is used to manage deposits and accounts. RealDigital itself stands as a reserve for all tokens of other participants. As we have different ERC-20 tokens for each participant they cannot be transferred directly, for this purpose swap contracts are used additionally. Therefore, when different tokens (RealTokenizado) are transferred between participants, it looks this way: RealTokenizado tokens (of one participant) are burned from the sender, RealDigital tokens (represent a reserve) are transferred from the sender to the receiver and RealTokenizado tokens (of another participant) are issued to the receiver. In this architecture there are also roles responsible for issuing, burning, moving and freezing funds. It is also important to say that participants, such as commercial banks, operate through a special account established by the Central Bank and cannot independently issue or burn RealTokenizado tokens. Stages of CBDC implementation worldwide In the first half of 2021, only 74 countries were interested in CBDC. Of these, only 3 decided not to develop this direction, 28 countries were in the research stage, 14 countries were in the development stage, 18 countries launched their own CBDCs in pilot mode and 1 country completely launched. By mid-2023, the picture has changed significantly, from the key parameters - now 130 countries have expressed interest, of which 46 are in the research stage and 32 are in the development stage. Pilot mode has been launched in 21 countries and 11 countries have fully launched. It is important to note that these 130 countries that are expressing interest in CBDC represent 98% of the world's GDP. From this we can conclude that this direction is of interest to the majority of countries in the world and has huge potential, and the active growth in the rate of research and development indicate that it is likely to be realised on a grand scale. The world situation at the moment is as follows: My opinion on CBDCs Even though many crypto enthusiasts believe that current CBDC implementations by central banks are not in line with the basic principles of the crypto community, I suppose that CBDC implementations should not be measured by public blockchains. CBDC implementations most often have fully centralized control, which crypto enthusiasts are against, but it should be understood that CBDCs cannot and should not be implemented otherwise. This is due to many considerations, including privacy and legality of transactions.  Yes, such a centralized implementation loses some of the advantages of public blockchains, but at the same time, it solves more important country-specific issues and reduces risks. Conclusion There is a significant global interest in CBDC implementation, which indicates a high promise of changing the traditional system towards CBDC and tokenization of assets. For CBDC implementation, private solutions are used that provide privacy control and centralized control over the Central Bank. They also support a high level of programmability, which makes it possible to create your own rules for CBDC. Unlike public networks, there are no transaction fees. Because transactions occur according to programmed rules - there is no need for a third party to verify them, and therefore these solutions are available 24/7. Control over the private network is limited to selected members and there is no need to wait for the majority to agree as in the case of public networks. CBDCs enable the tokenization of assets and property, optimizing the costs of the current registry infrastructure and increasing security, speed, and cost of transactions. Smart contracts in CBDCs open up opportunities to automate many processes and increase their security, including cross-border payments. Digitizing money makes it more transparent, efficient, controllable and accessible, removing vulnerabilities and inefficiencies in the current infrastructure.

Now You Understand: Central Bank Digital Currency (CBDC)—Explanation and Usage, Part 2

In the modern world, all of our actions come under the scrutiny of authorities and corporations. The former watch where we earn money, the latter whether we spend it “correctly”. The state tried to take control of even a person’s thoughts. The emergence of the Internet marked a chance for the free exchange of ideas and information. Cryptoanarchists began to actively use this chance. Cryptoanarchy is a political and philosophical ideology that calls for the use of cryptographic technologies such as encryption and digital currencies to achieve greater personal freedom, privacy, and autonomy from centralized authorities, including governments and corporations. Cryptoanarchists subscribe to the ideas that all communication should be private and anonymous if the individual wants it to be, especially in times where one can go to jail for saying the “wrong” word. Anonymity is the catalyst for people to lose their fear of sharing their thoughts, creating a field for free communication. The next important component is the autonomy and decentralization that the Internet has given people. With proper utilization of the network, a user can stay out of the sight of authorities and corporations. All the above mentioned benefits can be achieved with the help of cryptography. Cryptography Cryptography has its roots in wartime, when the secure transmission of information was vital. Primitive methods of encrypting forwarded messages meant that within a short period of time the key to decryption would be found. This meant that the threat of decryption was permanently present. There were many instances in the history of World War II where the key was solved before the message reached the recipient. This encouraged the military and governments to create ever more sophisticated forms of encryption. Many movies have been made on this subject. In the post-war period, these technologies were improved by governments. The USA took a special part in this process. For example, the well-known Tor browser was developed by the U.S. intelligence services for military and political purposes, but we will talk more about this in another article. So, today cryptography has reached the point where even the most powerful computer in the world would take about 150–200 years to find the key. This makes the blockchain system, which is based on public key cryptography, as secure as possible today. The essence of this system is that it generates 2 different keys for each user of the network. One key is public and the other is private. The combination of the public and private key unlocks the data in the registry. This combination allows operations to be secure and anonymous today. Please note that it is for today, as technology is moving forward continuously, and hackers are not slumbering either, improving and perfecting possible attacks. What is safe this second may not be safe in an hour. It is important to actively monitor information to stay up-to-date on the latest information security developments. Cypherpunks and cryptoanarchy In the second half of the 1980s, when there was a threat of governments controlling the free Internet, a movement of cypherpunks emerged that advocated the privacy of all activities on the Internet. It was they who went on to improve cryptography technology. Over time, their ideas began to affect not only confidential communication on the network, but also problems of a governmental nature. By the end of the last century, it became obvious that the mistakes of the government are very expensive for ordinary people. The ideology of the cypherpunks was based on freedom from government control and oppression. Realization that taxpayers’ money was being spent on wars and political intrigues, prompted these people to carry out activities against the state. One prominent example is the emergence of WikiLeaks, which publicized abuses of power. Today, the cypherpunk movements have expanded beyond a small Internet community and have gained followers all over the world and among different social classes. Now virtual communities based on similar ideology can be found in any language, some even have a physical location. Virtual communities and projects One of the prime examples of a virtual community is Cyberpunks. It was they who created the first platform where participants could anonymously share their ideas, discuss theories and collaborate on projects. It was there that the idea of creating digital money, which formed the basis of the Bitcoin philosophy, was first conceived. Concepts such as public key cryptography, digital signatures and hash functions, which are fundamental to Bitcoin’s operation, were topics of intense discussion among community members. In fact, Cyberpunks was not just a forum, but an incubator of revolutionary ideas and technologies that have shaped our future. The identity of Satoshi Nakomoto, the creator or creators of Bitcoin, is unknown to this day, but it can be assumed that he/she/they either directly participated in these discussions or actively observed them. One way or another all of these ideas formed the basis of Bitcoin. Anonymous payments and cryptoanarchism As we have already found out above, cryptoanarchism is impossible without making anonymous payments. The first step in getting rid of government control is the freedom of money. In today’s world, any transaction that a bank does not like can lead to account blocking and sometimes even litigation. The world lives under the illusion that people own their money and property, but in reality this is not the case. I dare to assume that every person has faced the fact that at any moment there can be a call from the bank with a demand to report on the origin of funds or the purpose of payment. In case of unsatisfactory answer, access to funds may be blocked. In today’s banking system, confidentiality is simply impossible. Banks see where we eat, where we buy clothes, at which gas stations we fill up, to whom we transfer our money. If necessary, all this information (by which geolocation can be established in a matter of minutes), will be transferred to the state authorities. Is it possible to avoid total state control? The answer is positive. We will talk about the possibility of anonymous payments in the next article.

The Cryptoanarchist's Cookbook

Oh the world of blockchain technology, once such a calm and peaceful realm, where we lay under the trees of Bitcoin-topia, the only thoughts running through our minds was the blazing hopes of liberation from the clutches of calamitous monetary policy and dubious governments, using Satoshi’s golden gift to the world. Times have changed, and now we are spoiled for choice, as there are a plethora of different ecosystems we may choose to call home, all with their draws and benefits. The initial lack of interoperability between ecosystems led to many questions being asked; do we need all these chains? how do we transfer between them? How can we increase interoperability? What's the point? what does the future of the blockchain world look like? , and it’s time to give the people what they want and clear it all up. Every answer leads us to encounter the same 3 buzzwords The definitive differences between Omnichain, Multichain and Cross-Chain Let's nail down one key detail that brings all of this together: Interoperability What is Interoperability When we talk about interoperability, we generally refer to the way networks communicate data to each other. This is a pivotal factor in a decentralised ecosystem, as without interoperablility, there is no way for users to send data to and from different networks. Previously, Ethereum network held upwards of 95% of all the TVL, and to get across to other networks was quite arduous, as well as time and resource-consuming — generally just a pain. The lack of interoperability was a serious issue and is something that needed to be solved. Before delving deeper, we need to understand why there are so many different networks, and it all stems from the Blockchain Trilemma. What is the Blockchain Trilemma? As is in the real world, we can’t have it all. For Blockchains, the sacrificial scale is called the Blockchain Trilemma. There are 3 main points to this Trilemma (naturally) and they are: — The ability of a blockchain network to manage high transaction volumes efficiently. Scalability Decentralization is essentially the dispersion of decision-making power away from a central authority, to many individuals, in this case, it would be to nodes. Decentralisation — This refers to the integration of a complete risk management system, where trust in transactions is ensured through the foundations of a blockchain security framework (consensus, cryptography, and decentralization). Security — , as to achieve efficiency in 2 points, one must be sacrificed. This is where we saw the developments in Layer 2 networks (Optimism, Arbitrum, Polygon etc) begin, as they solved the issues that Ethereum (A Layer 1) had with scalability. Layer 1 Blockchains suffer from this curse (the main blockchain). By being built on top of a Layer 1 network, the Layer 2 networks benefit from the decentralisation and security the Layer 1 has and then use their technology to fix the issues with scalability, thus solving the Trilemma (albeit at the cost of a slightly more complicated user experience). Layer 2 Networks sit atop of Layer 1 Networks The way they do this can vary depending on the Layer 2 — whether they be Optimistic Rollups (Optimism, Arbitrum), zkRollups (zkSynce, Starknet) or sidechains (Polygon). At the end of the day, they all reduce transaction costs significantly and have much higher Transactions per Second than their parent chain. This can be a lot to take in, and it may seem that this is a slight deviation but it’s important, as many new chains are being created in an attempt to solve this Trilemma, but ultimately, they were all inherently different and previously unconnected. This brings us to DeFi Summer (AKA Summer of 2020), and the rise of CrossChain Bridges. What is a Cross-Chain Bridge? Thankfully, the definition of a cross-chain bridge is quite intuitive — it bridges data between unrelated networks. The beauty of bridges is that they take manual labour out of the equation, and save a lot of time. Let’s say we have 1ETH — an ERC20 token, and we want to transfer it to the Solana network. Previously, you would have had to go through a centralised exchange (CEX), sell your for Solana, withdraw it to the Solana network, and then you would be left with 1ETH~ worth of Solana, which you can do what you want with. This process can be time-consuming (authenticate this and that), resource intensive, and if you are trading, can cost you an opportunity. Cross Chain Bridges fix this. ETH How does a Cross-Chain Bridge work? Cross-Chain Bridges, like the , have changed the game, and are part of the reason why DeFi Summer, was DeFi Summer. Multichain Bridge They work as follows, users typically lock or burn digital assets on the original chain and unlocks or mints the digital assets on the new chain. The whole process is governed by smart contracts, and hence why bridged assets are referred to as “wrapped assets” — cosily bundled up in smart contracts. For example, lets say there’s a liquidity pool on a Solana-based Decentralised Exchange (DEX), that requires Wrapped Ethereum and some stablecoin as the LP. What would happen is I would take my ERC20 Ethereum to a bridge, lock it to receive some wETH — Wrapped Ethereum — as sort of IOU which I can then move freely around the Solana network and deposit into the liquidity pool with an equal amount of stables. Cross-Chain Bridge Mechanisms There are 3 Cross-Chain bridge mechanisms that are used: and — Users burn assets on the original chain, and the equivalent assets are minted on the new chain. Burn mint — Users lock assets in a smart contract on one chain, and simultaneously, wrapped tokens will be minted on the target chain, with a 1:1 conversion. When reverting back, wrapped tokens on the destination chain are burned to unlock the original assets on the original chain. Lock and mint — Users lock assets on the first chain to unlock the same assets in a liquidity pool on the target chain Lock and unlock Issues with Cross-Chain Bridges No one is perfect, and bridges are not a person nor an exception. Bridges have been prime targets for hackers, for a few reasons. I will try to keep it simple here but it can get a bit technical so bear with me! As we have discussed, when bridging assets you lock/burn/deposit them on one end, to have them unlocked/minted/credited on the other. The notion that the asset conversion is guaranteed is actually incorrect, as the bridges don’t exist on a single blockchain — they in themselves are an external entity. As a result, no blockchain can verify the bridge! Verification is done by 3rd parties, the dynamic duo of Oracles and validators & custodians (usually in the form of a DAO or Smart Contracts). This added layer of reliance on 3rd parties destabilizes the trustless system and creates weak points which hackers can, exploit. and have, explains the vulnerabilities very well in his piece — highly recommend reading it. Ronal Thapa Is it Worth it to Use Cross-Chain Bridges? Cross Chain bridges give us a solution to the lack of interoperability, in a pretty seamless manner and save a lot of time when transferring assets between chains, and make it a lot easier to diversify your portfolio. Just make sure you are using a trusted bridge, have enough money for Gas and that the asset you are bridging is liquid enough on the target chain! Cross-chain bridges are good for linking 1 chain to another and facilitating that one-to-one network relationship but ultimately don’t . This is where Multichain comes into play. scale What is Multichain? When we speak about Multichain, we are referring to either: Multichain dApps Multichain Networks (or Modular Blockchains) What are Multichain Decentralised Applications (dApps) A Multichain Decentralised Application (dApp), is a project that has been deployed across multiple blockchains, specifically ones that share the same smart contract technology. For example, Ethereum, Polygon and Arbitrum all use the Ethereum Virtual Machine (EVM) — we call these EVM Compatible chains, and so multichain dApps can be built across those. Whilst Multichain applications are more widely accessible, allowing projects to scale with greater ease, there is still a widespread User Experience issue, for the most part, users are expected to switch networks on wallets when depending on where they are using the app, and for newcomers, it can pose as a severe roadblock. Moreover, having an dApp spread over multiple networks can lead to fragmented liquidity — which can severely harm the user experience further. The ideal state would be that you can connect wallets to multiple networks simultaneously, and access liquidity across all networks the dApp is built on. Seamless access. What are Multichain and Modular blockchains Often referred to as Modular Blockchains, Multichain networks are blockchains that have multiple, separate chains broken down into “layers” to perform different asks. This differs vastly from the general Layer 1 Blockchain — which for the most part uses a Monolithic structure. Think about it a bit like outsourcing. If the Blockchain was a company, a “monolithic” company would do everything in-house, but a “modular” company would outsource tasks to specialists Understanding Blockchain architecture can be tricky, but . ZebPay have done a good job of explaining it Benefits of Multichain and Modular Networks The benefits of Modular blockchain/Multichain networks are similar to those of Layer 2's Scalability — allowing specific chains to carry out specialised tasks brings greater efficiency and scalability to the overall network Security — Modular blockchains have shared security, which makes deploying new blockchains like rollups don’t require bootstrapping a new validator set, and means that new chains added to the network can benefit from the existing security. Lower Costs — Rollup SDKs, will not only help facilitate the low-cost creation of new blockchains, by providing a way to bootstrap without needing a consensus mechanism, large validator set, or token distribution. Super neat. What exactly is Omnichain and Layer 0? There is a lot of confusion as to what Omnichain/Layer 0 actually is. Most pieces I read threw around abstract thoughts and ideas of seamless interoperability and generic definitions for the implication of the prefix omni, without really hitting what we really mean. Looking back at what Multichain is, we mentioned that the dApps and networks had to be compatible, ie use the same smart contract technology — such as the Ethereum Virtual Machine. Omnichain is connecting all chains — regardless of their smart contract technology — by building a base layer (Layer 0) where all other networks and dApps can be situated on top of. A mega-multichain ecosystem that does not discriminate. With all these different layers and chains it can get tricky to visualise, so here's a simple way to think about it — The City analogy: Layer 0 — The main infrastructure (sewers, electricity grid, highways) Layer 1 — The Counties/States Layer 2 —Cities/Towns dApps — Stores and attractions Although this is quite simplified, it should give a slightly better idea as to how the system comes together. dApps can be built on Layer 1’s and not on Layer 2’s, and vice versa. For example, a dApp can be built and accessed on Polygon, but not accessible via Ethereum, and same goes the otherway round. The rise of Layer 0 and Omnichain brings us ever closer to a seamless web3 experience, with complete interoperability, minimal fragmentation and a much easier user experience. Projects like LayerZero, Polkadot and Cosmos all fall into this Layer 0/ Omnichain infrastructure category and are pioneering the future and mass adoption of blockchain infrastructure. Crosschain, Multichain and Omnichain all play their parts in the wider web3 world, and as we discussed, are all very different. I hope this piece cleared up the confusion!

Omnichain vs Multichain vs CrossChain: What Are They?

Omnichain vs Multichain vs CrossChain: ¿Qué son?

Omnichain vs Multichain vs CrossChain : qu'est-ce que c'est ?

ओमनीचैन बनाम मल्टीचैन बनाम क्रॉसचैन: वे क्या हैं?

オムニチェーン vs マルチチェーン vs クロスチェーン: それらは何ですか?

Omnichain vs Multichain vs CrossChain: O que são?

Omnichain vs Multichain vs CrossChain: Chúng là gì?

Omnichain vs Multichain vs CrossChain：它们是什么？

The Forms of Erotic Symbolism are Simulacra of Coitus

reating and deploying your own tokens on the internet is too easy. Blockchain and Smart Contracts have made it possible. Yes, you heard that right. You can deploy your own tokens on the internet. And that too without creating a whole new blockchain like Bitcoin or Ethereum. C These Tokens are just a piece of code running on top of a blockchain. Here’s a on blockchain. quick primer As a part of my learning I started learning about token standards and the problem I faced was the lack of resources where you can find everything about a token standard. Not a single resource was containing everything about a token standard.ERC20 was easy so it didn’t take much time. But ERC721 and ERC1155 took too much time to gather information and put them all together. Yes, it was easy to import Openzeppelin contracts and create the tokens but you will only learn the concepts if you practice all by yourself. So, just read these posts and start developing and deploying your tokens. Why am I writing this? Let’s get started with tokens. Prerequisites knowledge of solidity language and how it works (deployment and interaction). Knowledge about interfaces. (Here’s a handy ) resource Basically, tokens are a type of cryptocurrency that runs on top of a blockchain with some special use cases, for example, you can create tokens to fund your projects which are called ICO(Initial Coin Offering) similar to the share market, or you can also use tokens to assign a particular digital asset which has a specific value, apart from this, tokens can be used to represent ownership for some kind of data. They are also being used in governance, how? The person holding a specific amount of token of a company gets the privilege to vote for the company’s decisions. And there are many more use cases. The only thing you need is a Smart Contract deployed on a blockchain. Now there is a problem with interoperability, as there are billions of people with different ideas so it will become very difficult to utilize those tokens if every person is creating a new kind of token. This is because every token is nothing but a smart contract running on the blockchain, and smart contracts are codes written by developers. And different developers might implement the code in different ways. There would be chaos all over the network. Because the wallet providers and exchanges will have to write custom code to talk to different contracts with different kinds of functionality. Simply put, it’s impossible to write custom code for each contract individually. To overcome this we have token standards. ERC Ethereum Request for Comments ERC means Which helps the Ethereum environment to set rules or standards for the application layer of Ethereum Blockchain and make it more secure and scalable. Don’t get confused between ERC and EIP, EIPs are the proposals for core Ethereum functions and ERC is for the application layer. ERCs are a part of EIPs. . Ethereum Request for Comments. Learn more ERC token standards have a set of predefined rules that the developer should strictly follow while developing a token. There are different token standards as per demands. And they all have different sets of rules. Token standards give you an interface that you must implement when developing the respective token contract. You can add other functionalities also as per your demand but the standard interface should be implemented. Different ERC Standards There are lots of different ERC token standards out there but we will talk about some most popular and more commonly used ones. Which are . There are many more standards that are being proposed to improve the old ones with backward compatibility, we will talk about them on the go. ERC-20, ERC-721, and ERC-1155 ERC-20 — Fungible TokensERC-721 — Non-Fungible TokensERC-1155 — Both Fungible and Non-Fungible Tokens(Also semi-Fungible) Don’t know the difference between Fungible and Non-Fungible? Let’s learn. tokens can be defined as interchangeable, which means if you and I have 100 tokens, then we can exchange them and nothing will change. No profit no loss. Everything will be the same as before. Similar to any fiat currency like Dollars, Euros, Rupees, etc. Fungible tokens( ) are just the opposite of this. Which means every token is different from the other one. Every token is unique. Because Non-Fungible tokens are not only the representation of digits but they have external assets assigned to them, for example, any image, painting, ticket for a concert, music file, game collectibles, and many more things. This is why they are unique. Non-fungible NFTs The first standard to be proposed on the Ethereum network which is the most famous and basic one that comes to everyone’s mind when we talk about the token standard is the token standard. ERC-20 ERC-20 ERC-20 token standard was proposed in 2015 for fungible tokens. Fungible means interchangeable i.e. every token is the same as another token. This standard has nine functions and two events that should be implemented while creating an ERC-20 token. ERC-20 has the following functionalities: transfer tokens from one account to another. get the current token balance of an account. get the name, decimal, total supply, and symbol of the token available on the network. approve whether a number of tokens from an account can be spent by a third-party account. Let’s have a look at the ERC-20 interface. ERC20 Interface pragma solidity 
^0.8.0;
  interface IERC20 { 
      event Transfer(address indexed from, address indexed to, uint256 value); 
      event Approval(address indexed owner, address indexed spender, uint256 value); 
      function totalSupply() external view returns (uint256); 
      function balanceOf(address account) external view returns (uint256); 
      function transfer(address to, uint256 amount) external returns (bool); 
      function allowance(address owner, address spender) external view returns (uint256);
      function approve(address spender, uint256 amount) external returns (bool);
      function transferFrom(address from, address to, uint256 amount) external returns (bool);
  } First, we will see the functions. The first three functions, which are the , , and are considered to be optional and not included in the interface of an ERC20 contract. But they are really important and we can’t ignore them. name() symbol() decimal() The function should return the name of the token which is stored in a state variable. 1. name() function name()public view returns (string); The function should return the abbreviation of the token and this is also stored in a state variable. 2. symbol() function symbol()public view returns (string); is the important one to notice because solidity doesn’t support floating numbers and in order to perform transactions with values like 1.5, 2.4, etc., we have to break the number into lower denominations. Remember how the ether token can be broken into lower denominations like Gwei, Finney, and Wei. Normally we assign 18 decimals points and it is also recommended to do so. 3. decimals() function decimals()public view returns (uint8); This function should return the total amount of tokens in the market. Total supply of a token should only be affected by two functions, minting or burning. Minting means supplying newly created tokens and burning means destroying the tokens. We will talk about both of these later. 4. totalSupply() function totalSupply()public view returns (uint256); takes an address as an argument and returns its token balance. How does it know about my balance?We define a mapping inside our contract which keeps track of our balance, every time there is a transaction of tokens this mapping should be updated as this would be the only source of balance.This is what the mapping looks like: 5. balanceOf () mapping(address => uint ) internal balance; This function just returns the value from mapping. balanceOf function balanceOf(address _owner)public viewreturns (uint256 balance); is the function used to send tokens from one address to another. Takes an to which tokens are supposed to be sent and a which is the number of tokens to be sent, as arguments. And it should deduct the tokens from and add the amount to the recipient. How do the deduction and addition work? As I said earlier about the mapping. We simply decrease and increase the number of tokens in the mapping. 6. transfer() address uint msg.sender balance function transfer(address _to, uint256 _value)publicreturns (bool success); does the same thing as the function but there is a difference. This function is used to send tokens from one address to another address by a third address. How can someone spend my tokens? Is it safe? Yes, because any address can only spend your token if you have approved it to do so. How do we do it? That’s what the next function is about. 7. transferFrom() transfer function transferFrom(address _from, address _to, uint256 _value)public returns (bool success); 8. is used to approve any account to spend tokens from the account that is approving it. It takes two arguments first is the address of the spender and the second is the value of tokens that the spender is allowed to spend. We then update the nested mapping with this input. Which mapping?The mapping for approval is written like this: approve() mapping (address=> mapping (address => amount)) internal allowed; function approve(address _spender, uint256 _value)public returns (bool success); 9. is used to check the remaining tokens for the approved address to spend. It simply returns the data reading from the mapping. allowance() allowed function allowance(address _owner, address _spender)public view returns (uint256 remaining); These were the functions to be defined while creating an ERC20 token. Apart from these, we have two events that must be triggered at the desired times. They are: Every time there is a transfer of tokens from one account to another, this event should be triggered. It’s pretty obvious that this should emit inside the functions transfer and transferFrom. But there are two more functions at the time of implementation where this event is emitted. and functions. We will talk about these in a while. For now, just remember when emitting this event in a function, the sender address should be zero address, and in a function, the receiver should be zero address. Zero address looks like this: In solidity means this zero address. Transfer: Mint burn mint burn 0x0000000000000000000000000000000000000000 address(0) event Transfer(address indexed _from, address indexed _to, uint256 _value); This event should be triggered inside the function, every time someone approves any address. Approval: approve event Approval(address indexed _owner, address indexed _spender, uint256 _value); Every ERC20 token should implement these functions in the contract. Have a look at this simple implemented smart contract. // SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface ERC20Interface {

function allowance(address tokenOwner, address spender) public virtual view returns (uint remaining);
function balanceOf(address tokenOwner) public virtual view returns (uint balance);
function totalSupply() public view virtual returns  (uint);
function transferFrom(address from, address to, uint tokens) public virtual returns (bool success);
function transfer(address to, uint tokens) public virtual returns (bool success);
function approve(address spender, uint tokens) public virtual returns (bool success);

event Transfer(address indexed from, address indexed to, uint tokens);  
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);  
event Supply(address indexed to, uint indexed amount, uint remainingSupply);  

}

contract Token is ERC20Interface  {
string public name;
string public symbol;
uint8 public decimals;
uint256 public _totalSupply;
uint public maximumSupply;
address public owner;

mapping(address => uint) private balances;  
mapping(address => mapping(address => uint)) private  allowed;  

constructor()  {  
    name = "MyFirstToken";  
    symbol = "MFT";  
    decimals = 18;  
    _totalSupply =  5000000 * 10**18;  
    maximumSupply = 10000000 * 10**18;  
    owner= msg.sender;  

    balances[msg.sender] = _totalSupply;  
    emit Transfer(address(0), msg.sender, _totalSupply);  
}  
  
function  remainingToken() public view returns (uint remainingSupply) {  

    return ( maximumSupply - _totalSupply);  
}  


modifier ownable ()  {  
    require (msg.sender== owner," only owner can perform this");  
    _;  
}  

function totalSupply() public override view returns (uint) {  
    return _totalSupply ;  
}  

function balanceOf(address tokenOwner) public override view returns (uint balance) {  
    return balances[tokenOwner];  
}  

function allowance(address tokenOwner, address spender) public override view returns (uint remaining) {  
    return allowed[tokenOwner][spender];  
}  

function approve(address spender, uint tokens) public override returns (bool success)  {  
    allowed[msg.sender][spender] = tokens;  
    emit Approval(msg.sender, spender, tokens);  
    return true;  
}  

function transfer(address to, uint tokens) public override returns (bool success) {  
    balances[msg.sender] = (balances[msg.sender] -= tokens);  
    balances[to] = (balances[to] += tokens);  
    emit Transfer(msg.sender, to, tokens);  
    return true;  
}  

function transferFrom(address from, address to, uint tokens) public override returns (bool success) {  
    require(balances[from] >=tokens, "You don't have enough tokens");  
    require(allowed[from][msg.sender] >=tokens, "You are not allowed to send tokens");  
    balances[from] = (balances[from] -= tokens);  
    allowed[from][msg.sender] = (allowed[from][msg.sender] -= tokens);  
    balances[to] = (balances[to]+= tokens);  
    emit Transfer(from, to, tokens);  
    return true;  
}  

function mint (address to ,uint amount) public ownable {  
   require(_totalSupply + amount <= maximumSupply,"You are exceeding the maximum supply");  
   balances[to] += amount;  
   _totalSupply += amount;  
   emit Supply(to,amount,remainingToken());  
}  

function burn (uint amount) public {  
    require(balances[msg.sender] >= amount, "not enough balance to burn");  
    balances[msg.sender] -= amount;  
    emit Supply(msg.sender, amount, remainingToken());  
} } This is a really simple implementation where you can see the contract token inherits from the interface and implements every function defined inside the interface.Notice there is two extra functions and . mint burn MINT The function is for minting new tokens. When you see the code inside it, you will notice that it increases the balance of any address. Which means there are new tokens being minted to that wallet. But why do we emit the transfer event here? This is because minting is considered as a transfer of tokens from the zero address to the given address. mint BURN Now, what about the function? The function really is a transfer of tokens but the recipient is always a zero address. Why so? Zero address is being used as a black hole in Ethereum, which means it’s unlikely to guess the private key of the zero address. Let’s not be too much technical here, just get the point that whenever you need to destroy some token meaning remove the token from the market you send it to this address, and boom, it’s gone forever. nobody can access those tokens now. This is the reason zero address holds tokens worth millions of dollars. burn burn That’s pretty much it about the ERC20 token standard. This is really simple and easy. But this is only for fungible tokens, what about the non-fungible tokens NFTs? ERC-721 is the standard for NFTs. Let’s talk about this in the next post. Also published . here

Understanding Token Standards in Ethereum Part - I (ERC20)

Manifest Dream Content and Latent Dream Thought

This is the last part of the debugging series, to learn the rest you'll need to get or . the book the course One of the most frequently asked questions I receive is: can we do these things in VS Code? The answer is unfortunately no. But I elaborate on the debugging capabilities of VS Code in . I'll do a blog post that covers that next week. this video Below is the last video in the series: https://www.youtube.com/watch?v=ImOmu4GHOls&embedable=true Transcript Welcome back to the ninth part of debugging at scale where we really know the quality of your code. Remote debugging doesn’t always deal with a remote machine, we often need it when debugging into Kubernetes or Docker. We’ll delve more into that later, but for now, we’ll discuss the basic mechanics. How to connect, how to make it slightly less vulnerable to security attacks, and then we’ll discuss the problems of remote debugging. The Connection and Command Line We’ll start with a discussion around the connection. We first need to run the process that we’ll connect to remotely. To do that, we need to run a command similar to this one. Notice that this is a simplified version; in many cases, the argument should be embedded in configuration files. When you inspect your maven or gradle files, you might see many of the arguments listed here. This is how these things work under the hood. Let’s go over the command and break it down piece by piece to see that we understand it correctly. The first part is the launch of the Java command line. This is pretty obvious. We need quotes in bash since there’s a star at the end of the line, and bash wants to expand it. Without this quote, the command won’t work properly. Agent lib is the system that loads the native library wiring directly into the virtual machine, and JDWP is the Java Debug Wire Protocol. This is the underlying networking protocol used to communicate between the debugger and the running process. It’s a high-level protocol, which means it can be implemented on top of various transports. Typically, it’s implemented over TCP sockets, but it’s the same protocol we used to debug devices directly. You don’t need to know too much about JDWP, but the concept is simple, you send commands and can query the system. That’s what the IDE does for you. When you add a breakpoint, the IDE sends a JDWP command to add a breakpoint at the given location. When the breakpoint is hit, JDWP sends back an event to the IDE indicating that. The IDE can then query the details about the current environment, stack, variables, etc. In this case, we transfer the details via a server socket. We can use dt_shmem which stands for shared memory as the wire protocol. This is faster and useful for processes that have access to a shared memory area. This is actually pluggable, and you can build your own JDWP transport. This isn’t useful usually but speaks to the power and flexibility of the API. We can optionally suspend the virtual machine on launch if you want to debug something right from the start. I’ve set this to no which means the VM will start running right away. If you set it to yes with the letter y, the VM will pause on launch and wait for the JDWP connection. This is the address and port we are listening on. In this case, I allow anyone to connect on port 5005. I can limit this to localhost only by changing the star character. This is probably the better approach, although it won’t make the protocol fully secure. This is the rest of the command for the class we’re running. Typically, you would have something more substantial here. In this case, I’m just running the PrimeMain class. To start debugging, we need to edit the run configuration in IntelliJ. Connecting From IntelliJ/IDEA Next, we need to locate a configuration for remote debugging. Once I select that, we can add it. Notice it’s pre-configured with the defaults such as port 5005. I give the new run configuration a name, and we’re ready to go with debugging the app. Notice there are many options to tune here, but we don’t need any of them. Also, check out this area right here. Seems familiar? That’s the exact line we discussed before. The IDE is showing us how to set up the command line for the remote process. This lets us verify that we entered everything correctly. We now have a new Debug Remote run configuration. We can switch to a different configuration from the same location. But when we want to do remote debugging, we need to toggle it here. Next, we need to press the debug button to run this command. We are now instantly connected to the running process. Once that is done, this feels and acts like any debugger instance launched from within the IDE. I can set a breakpoint, step over, inspect variables, etc. So why do it? In some cases, running the server locally in the IDE is impractical. A good example would be debugging a container on your own machine. That might not be trivial. Security Implications of JDWP Calling JDWP insecure is inaccurate. That would be like putting your house keys and home address wrapped in a nice gift wrapping with an itemized list of your valuables sorted by value in front of your house. This is an open door. An open door isn’t a security vulnerability. It’s an open door! JDWP is very insecure when used remotely. Locally, on your own machine, it isn’t a problem, but it has almost no security protections. There’s no solution for that. But there’s a very partial workaround for tunneling it over SSH. This is relatively trivial. Just use this command to open a tunnel between the remote machine to your local machine. For both sides, it will seem like local debugging. So, the example I showed before of connecting to a local host server, would work perfectly with this remote host as SSH will move all the packets back and forth. Securely. We can’t ssh into a Kubernetes container, but we can port forward which is almost identical. We can do something similar to this command to forward the port from the given pod to the local machine and vice versa. Same idea as SSH tunneling but appropriated to the Kubernetes world. Dangers of Remote Debugging In this final section, I want to talk about the dangers of remote debugging in production. Breakpoints break seems obvious. That’s what they’re here to do. But if we run on a server, we block it completely by mistake. We can use trace points. As I said, they’re great. But they are no replacement for breakpoints, and an accidental click in the gutter can literally stop your server in its tracks. JDWP effectively allows remote code execution. It lets you access all the bytecode of the app which is effectively the same as giving access to your full source code. It lets attackers do almost anything since it wasn’t designed with security in mind. We need to relaunch the application with debugging enabled. That means killing the running process and starting it over again. Disconnecting existing users, etc. That isn’t great. Some operations in the debugger require more than one step in terms of the protocol. As a result, you could send a request to the debuggee, lose your connection, and the debuggee could be stuck in a problematic state. This is an inherent limitation of the JDWP protocol and can’t be worked around in a standard debugger. The problem is that even unintentional actions can demolish a server. A simple conditional breakpoint that invokes a method as part of the condition can demolish server performance and crash it. JDWP effectively allows remote code execution. It lets you access all the bytecode of the app which is effectively the same as giving access to your full source code. It lets attackers do almost anything since it wasn’t designed with security in mind. Imagine placing a breakpoint where the user password is passed to authentication… If JDWP is open for your server, a member of your team might use that, and you will never know! There’s no tracking at all! 60% of security hacks happen from within the organization. If your company does remote debugging, they have no way of knowing whether an employee used that to manipulate the application state or siphon user details. There’s no tracking or anything. This can be in violation of various rules and regulations since it might expose personal user data. Remote debugging into production can trigger liability risks. I discuss some of the solutions for those problems both in low-level tooling and in higher-level observability solutions. This is covered in the book and in the full course. Final Word With this, we finished the first part of the course. If you want to check out the full course, go to to learn more… The next video covers the strategies for debugging and the science of debugging. If you have any questions, please use the comments section. Thank you! debugagent.com Photo by on Eric Muhr Unsplash

Stories, News & Mentions about WETRANSFER

Wetransfer’s Stories on HackerNoon

Wetransfer's News & Mentions