The Task

It can be challenging to groom an AI to create content with a certain flair or flavor from a small amount of previously generated content. In general, the more data the AI has to work with, the better it will be able to learn the patterns and characteristics that define the desired style. With a small amount of data, it may be difficult for the AI to fully understand the nuances of the desired style, which can lead to less accurate and less realistic generated content.

However, if you only have a small amount of data to work with, there are still some steps you can take to try to improve the quality of the AI's generated content. One option is to augment your dataset by using techniques like data synthesis or text generation to generate additional training data. This can help the AI learn a wider range of patterns and characteristics, which may improve the quality of the generated content.

Another option is to use a technique called transfer learning to fine-tune the AI's existing knowledge to the specific characteristics of your dataset. Transfer learning involves taking a pre-trained AI model that has already learned to generate text, and then adjusting its parameters to better fit the characteristics of your dataset. This can help the AI learn the nuances of the desired style more quickly and effectively, even with a small amount of data.

It's important to note that generating content with a certain style or flair is a difficult task, and there are no guarantees that the AI will be able to produce high-quality content with a small amount of training data. You may need to experiment with different techniques and approaches to find the best way to train your AI on your specific dataset.

The Blueprint

1. Collect a large dataset of text that has been written in the style you want the AI to learn. This dataset should include a variety of different examples that reflect the full range of patterns and characteristics that define the desired style.

2. Pre-process the dataset by cleaning and organizing the data to make it easier for the AI to learn from. This may include steps like removing punctuation and special characters, tokenizing the text, and converting the words to lowercase.

3. Use a natural language processing (NLP) technique like fine-tuning to train the AI on the dataset. Fine-tuning involves adjusting the AI's existing parameters, which were learned from a pre-trained model, to better fit the specific characteristics of the new dataset. This can help the AI learn the nuances of the desired style and generate more accurate and realistic content.

4. Test the AI's performance by having it generate new content and evaluating the results. You can use a variety of metrics to assess the quality of the generated content, such as grammar and spelling, coherence and cohesiveness, and overall fluency and style.

5. Adjust the AI's training and fine-tuning parameters as needed to improve the quality of the generated content. This may involve experimenting with different NLP techniques, adjusting the size and composition of the training dataset, or using techniques like data augmentation or transfer learning to improve the AI's ability to learn the desired style.

6. Continue to refine and improve the AI's performance over time by providing it with additional training data and making adjustments as needed. As the AI becomes more experienced, it should be able to generate higher-quality content that more closely matches the desired style and flair.

But I dont have a Large Dataset

If you want to decrease the amount of data needed to train an AI to create content with a certain flair or flavor, you can try using techniques like data augmentation or transfer learning.

Data augmentation involves generating additional training data based on the existing data you have. This can be done using techniques like text generation or data synthesis, which use AI algorithms to create new text that is similar to the original data. By augmenting your dataset in this way, you can provide the AI with more examples of the desired style, which may improve its ability to learn and generate content with that style.

Transfer learning involves using a pre-trained AI model that has already learned to generate text, and then fine-tuning its parameters to better fit the characteristics of your dataset. This can help the AI learn the desired style more quickly and effectively, even with a smaller amount of data. By using transfer learning, you can leverage the AI's existing knowledge to reduce the amount of data needed to train it for a specific task.

It's important to note that both of these techniques can be complex and may require specialized expertise to implement effectively. You may want to consult with a professional or conduct some research to learn more about how these techniques work and how to apply them in your specific situation.

Best Tools Available

There are a number of tools available that can be used to train an AI to create content with a certain flair or flavor. Some of the best tools for this task include natural language processing (NLP) frameworks like TensorFlow, PyTorch, and spaCy, which provide a range of pre-built models and algorithms that can be used to train and fine-tune AI models for text generation tasks.

Additionally, there are a number of open-source AI models and datasets available that can be used as a starting point for training an AI to generate text with a specific style or flair. For example, the GPT-3 model from OpenAI is a large-scale AI model that has been trained on a massive amount of text data and can be fine-tuned for a variety of natural language processing tasks, including text generation.

In addition to these tools, there are also a number of specialized AI platforms and services that offer pre-trained models and other resources for training AI models to generate text. For example, OpenAI offers a range of AI models and tools that can be used to train AI models for text generation tasks, and Google Cloud offers a Natural Language API that can be used to analyze and generate text with a specific style or flair.

Ultimately, the best tools for training an AI to generate content with a certain flair or flavor will depend on your specific needs and goals. You may want to research and experiment with different tools and approaches to find the ones that work best for your situation.

When will it be Commonplace?

It is difficult to predict with any certainty when AI-generated content with a specific style or flair will become a normal occurrence. As I mentioned earlier, generating content with a specific flair or flavor is a challenging task, and it may be some time before AI systems are able to produce high-quality content that matches the complexity and nuance of human-generated text.

Additionally, the use of AI for text generation is a contentious topic, and there are concerns about the potential impact of AI-generated content on industries like journalism and creative writing. It remains to be seen how these concerns will be addressed and how they will affect the future of AI-generated content.

With that said, AI technology is advancing rapidly, and it is possible that AI-generated content with a specific style or flair could become more common in the coming years. It is also possible that advances in AI technology could lead to the development of new tools and techniques that make it easier to train AI models to generate high-quality content with a specific style or flair. However, it is impossible to predict the exact timeline for these developments with any certainty.

About

The 0xZOZ account that was created at the beginning of 2022 was a way to utilize new tech, try things without judgment, and learn by failing. This whole article apart from the title, subtitles, and this section were created by AI, including the cover image. In early 2022, I knew AI would be a thing, In fact, my profile picture was generated by an AI model. Little did I know of the speed it would progress. Although the output is not perfect, you have to admit it is mindblowing that my idea to conception took less than 10 minutes! I have seen AI tools creep into my daily workflow and inprove efficiency greatly. Be it creating branding images, cover photos or having an assistant helping me code with Githubs co-pilot. These tools are truly amazing.

While some may see the downstream effects of this devastating for a lot of people and jobs that currently exist. I would argue that it opens doors to creativity people never had at their fingertips like this before. This leads me to the traits that will thrive in this rapidly changing and the ever-evolving world we are entering.

Creativity and execution.... If you start now, you will be ahead of the curve and have infinite tools available.

This was the first of many of my experiments incorporating AI into my workflow and fine tuning my ability to create with these new tools.

Set Up Environment

• Download and install VS Code

• Download and install Move Extention

• Install Suicargo install --locked --git https://github.com/MystenLabs/sui.git --branch devnet sui

• Install Sui Wallet

Create Front End

• Install Yarn

• Install create-react-app

Create App Connection Method

• We will be using Suiet Kit. It is a wallet connection library built specifically for SUI and the most used wallets.

• You can view a sample PR here that will show you how to add it to your application

Create Move Contracts

• Develop Modules - can copy/pasta any of these examples if needed

• Create a folder in the /src dir of your application and add the modules in a structure like this

Testing and Deploying Locally

• cd into the package - eg cd /src/contracts/your-package-name

• Build the package - sui move build

• Test the package(there are no tests currently in the example packages) - sui move test

Set Up Local Devnet

sui move does not have a publish function. We will use sui client to interact with a local network we set up below

• We will now create an extra terminal(Ctrl+` + Ctrl+Shift+`) in VSCode to run the following commands

  • sui genesis --force - This overwrites your current .sui folder at the root of your machine

  • sui start

The network that genesis creates includes four validators and five user accounts that contain five coin objects each. We will deploy using one of these accounts but we will also fund a browser wallet to interact as we would in the real world(see below)

• Move back to your other terminal and publish your projectsui client publish --gas-budget 1000

You will receive a certificate and the ID’s of the objects published from the package that will look like this

----- Certificate ----
Transaction Hash: H5mfT9UgoV+qW1kbWXT1HFvWzmSnPCxSgEplu3lI5UM=
Transaction Signature: AA==@Vga6rEHwv+ytGgIjR/krZtQcxAH1VXejqXDpekNWQ4Q/MWmeW+6NnFMvgvdiexJ9aJ0Wei41PxMC8JS6Ee3ICg==@WUoEWyFiMdiC5G4KUvAKKJgI9nks+et6+8qncumfJs4=
Signed Authorities Bitmap: RoaringBitmap<[0, 1, 2]>
Transaction Kind : Publish
----- Transaction Effects ----
Status : Success
Created Objects:
  - ID: 0x77e2392b2d77412b89533d7e5d9c82caed714822 , Owner: Immutable
  - ID: 0x9ada30b2e52c23ea36c9fb7c4905bc58ca44eabc , Owner: Account Address ( 0xf271faa139f3d1c992d43deba597686d392fc39a )
  - ID: 0xa4890ca9d1ba6b871f885fdc92396b8baae52549 , Owner: Shared
Mutated Objects:
  - ID: 0x08af5d44a99e483881c76fb106b025542a48ccec , Owner: Account Address ( 0xf271faa139f3d1c992d43deba597686d392fc39a )

To Note: in this instance we are publishing a module and two structs1. ID: 0x77....822 , Owner: Immutable - The module address as its immutable2. ID: 0x9...abc , Owner: Account Address ( 0xf...39a ) - A capability issued by the module on initialization3. ID: 0xa...549 , Owner: Shared - A registry created in the module and is shared

Fund your browser wallet

1. Find Sui Gas Object Idsui client objects

2. Transfer to your browser walletsui client transfer --to <BROWSER-WALLET-ADDRESS> --object-id <SUI-GAS-OBJECT-ID> --gas-budget 1000

Interacting with your Deployed Modules

• Create a .env file in the root of your project to add the addresses returned. You will need to install a package(env-cmd) and use it when you start your application. This can be done byyarn add env-cmd and then changing your scripts start cmd in package.json to something like this env-cmd -f .env react-scripts start

Example

REACT_APP_SUI_LOCAL_NETWORK_WORDSUIP_PACKAGE_ADDRESS=0xca32f75d60edbb2bb7057df93b0a29c32f81f670
REACT_APP_SUI_LOCAL_NETWORK_WORDSUIP_USER_MANAGER_CAP_ADDRESS=0xc2fa11f372ebdb056303067deb2174e99f446f4c
REACT_APP_SUI_LOCAL_NETWORK_WORDSUIP_USER_REGISTRY_ADDRESS=0x9088202aa9636adae4af8373a2135ac5e657e1f3

REACT_APP_NETWORK=local # || devnet || testnet || mainnet

REACT_APP_SUI_LOCAL_ENDPOINT=http://127.0.0.1:9000
REACT_APP_SUI_DEVNET_ENDPOINT=https://fullnode.devnet.sui.io

Create Client Side Interaction

• Create a folder /hooks and create a file called useSui.tsx. We will use this to store all of the contract interactions client side and be able to use it in our application. An example can be found here

• We can now manipulate the UI to utilize this hook and interact with our module on our local network.

• Open another terminal and start the application. you must be at the root of your create-react-appyarn start

You should now have 3 terminals open

1. Sui local network

2. Application

3. An extra one to interact/add packages etc whilst you are working

Resetting or Changing the Contract

• The idea of this developer environment is to be able to streamline our ability to develop Move applications. You can follow these steps to demolish your existing setup, make changes, redeploy and test.

1. Stop Sui local network in your Sui terminal

2. Nuke the db - sui genesis --force

3. Restart Sui local network - sui start

4. Make your desired changes in your contract, UI or both

5. Redeploy your contract - sui client publish --gas-budget 1000

6. Change your .env variables with the new addresses

7. Stop and Restart your application to recognize these changes CTRL + C and yarn start

8. Send Sui Gas to your browser wallet

TEST AWAY! Watch out for scaffold-move.xyz!

BOOMERS are the Generation that will be last to decide whether there is a use case within crypto that will impact normal life or it will impact normal life without them noticing. WOKES are the culture that has fought for so long to discredit the idea, industry, and movement. They will realize that pieces are being built and are useful to help the rights that they/them/all stand for. UP ONLY** **started as a meme during the largest bull market the industry has seen thus far but is smarter than it seems, while commonly seen as a reference to $$$ value, it actually represents PROGRESS

boomers + wokes = up only

We will describe here a glimmer of hope as we crawl our way out of the deep dark hole of deceit, lies, and mismanagement that has crippled trust in the crypto industry during 2022. We will give a recap of the previous cycles of innovation and how each led to attracting a new 'type' of individual and the next 'type' was dependent on the last.

Subsequently, we will then present why the next wave of participants and their cohorts/alignments is the last frontier before we see the new tech/old tech merge and it no longer being contested.

Recap of previous cycles

2009 - 2011

From the inception of Bitcoin and the industry to being talked about more broadly as a larger group. This was the progression from specialists to the broader range of their peers. Still very nascent but a few articles were in the media and knowledge spread outside of the core group of 'founders'.

2011-2013

More common now that it had its core group of specialist followers that would spread the word outside of their circles. As you imagine, the circles of the core knowledge demographic were directly related to tech workers. The growth of the following subset was wider-reaching than mostly specialists to a collection of tech workers, entrepreneurs, and hobbyists.

2013-2017

There was now a very diverse cohort that had tentacles across all cultures. The epochal explosion the industry would need to take it to just over saturation point. This was the moment that those unfamiliar with tech got their first glimpse of the tech in a prehistoric operating state. Nevertheless, with value tied to tech, it drew in speculators from all walks of life. Not many would stay but enough to kindle the fire.

2018 - 2021

While there were now believers from all walks of life, these were few and far between in their relative groups. Likely not taken seriously by their peers depending on the lifestyles they were associated with. This was about to change as some breakthrough MEMES would entrench cultures and fully grasp the mindset of the next generations. We went fully mainstream this last cycle, NFT's brought artists, trendsetters, and a culture of creators. Meanwhile, DeFi *captured TradFi's mind and showed that finance could be much more lightweight and transparent. We now have enough mindshare that the inevitability of this technology being intertwined into every aspect of our lives is only a matter of time. It just doesn't seem that way to most

What's Next?

There is still some pushback, especially after the very public blow-ups the industry saw in 2022. These come from what we will define as the last two big bosses due to their authority within the world. We will describe their reluctance, the importance, and what brings them on board over the next years.

Boomer

The Demographic: Ah, the Baby Boomers(people born from 1946 to 1964)! They come of age in the largest boom we have seen in the last few centuries. Where technology got exponentially better, but they were always slow to pick it up due to the world they were born in that was basically computer free. While life was humbler then, with less focus outside your given immediate environment. Crypto as a whole doesn't really make sense to the broader selection of the boomers and for due right. Why would something that is not tangible or is stored as bits be valuable outside of its realm? The world is fine as it is, the bank holds my money, I go to the grocery store to use that money, I use the apps on my devices and they work. These are all valid points and even more so conditioned thinking from deceptive behavior. It didn't all start out like this but incentives were aligned to create this end product.

This changes in the coming years as the younger generations that are digitally native start exposing the hidden obscure intricacies that can only be discovered by fresh eyes the systems that themselves were not built for. As the wool begins to be removed from their vision they will reluctantly need an alternative that can help them navigate. As the population ages, some adopt, others pass, and they will be the last to have fully known life before a percentage of their time was spent digitally and therefore understand the need for the tools that were being built from 2009 - the present.

Woke

The Culture: While we have seen widespread diversification of participants across the globe, so too has a culture that the overwhelming majority also viscerally HATES crypto. Woke culture has intercepted our world as a whole for better or worse. Some of the brightest minds subscribe to these ideals and want fairness in this world that ironically only crypto natives can appreciate. So why the disdain towards the industry? Well, we only have to look at the biggest feature of the technology, assigning value to bits and bytes! If you can theoretically produce value from nothing with relative ease, you attract opportunistic actors with questionable morals. What is the biggest feature is also the largest bug. With each cycle, there is around a 5% efficacy rate(a totally made-up number but you get the point) of users that stay after the trip. The other tourists go back to their daily lives either wrecked from the debris created by the demolishment of exuberance from months/year prior or simply bored from the lack of dopamine hits.

Why wouldn't they hate it with all that said? Of course they would but it's easy to dismiss the beauty of the bee after getting stung. What is missing is the path from reaction to revelation, once enough people can articulate the benefits that could be conceived from the toolkit. There is a realization that the same battles they fight could be prevented by embedding mechanisms into our digital infrastructure. Instead of fighting the issues, they could help rebuild from the ground up

Up

The Meme: In early 2021 a podcast was created and the name became a meme. Up Only was synonymous with the Zhupercycle, another meme created in a subsequent episode of the podcast. While only an idea(false but relevant at the time) it quickly became a belief for many as memories fade of the pain that was endured during the off years. Hell, maybe the majority had never felt the pain and was ignorant to the struggles OG's had suffered(they were just lucky after all). Yet in 2022, many of the believers got to feel that pain. Even the creator of the Zhupercycle meme was too long and ultimately lost everything.

While the money has evaporated, let's take a look to see if there is anything that still resembles an up-and-to-the-right chart. One particular metric always increases but it's not easy to see unless you have spent time on the ground. Developers, ideas, and projects always increase. If you are developing in the space you know that there is always work for talented individuals. Ironically we still are up only but most people don't realize it yet. The most active development is even happening on projects that have either just launched or haven't launched yet. A quick look at the most active Rust repositories over the last month shows two crypto projects in the top 5 - Sui and Aleo.

Just as DeFi was born at a time when most had identified the space as dead. In the next 2 years, we will open up scalable infrastructure, polished products, abstraction of clunky artifacts, and a narrative that you least expect will pop up that will seem dumb at first to most. In previous cycles it was conceivable to have a grasp of everything that was happening in the crypto world but this is no longer true. One can only meaningfully keep up with a couple of projects at a time, let alone ecosystems and frameworks.

Web2 companies now all have entire teams and products being built around Web3. With industry skeletons coming out of the closet in 2022, being transparent, not blindly trusting entities and a more resilient DeFi3.0 will be the norm.

The next time you hear the word crypto in an intriguing light will be the last. With the two bosses eventually slayed in the coming years. The technology will fully infiltrate society.

Wagmi? No, but it was never about making it. It was allowing everyone to have the tools to be on equal footing and not allow corruption by default. An unpopular opinion is the items that occurred in 2022 were actually the most beneficial over the last couple of years. It's darkest at dawn.

Cover Image

The image above(like my PP) is created with abraham.ai - an AI artwork generator

SEED: Boomer woke up

About

Twitter: @0xzoz

GitHub: @0xzoz

Mirror: @0xzoz

Discord: @zoz.eth#6952

ENS: zoz.eth

Maintaining a blockchain network node or validator is a lot of work to initially set up. Depending on the network there are varying levels of system administration work that needs to be done. Early in the life of a network, you will usually have to deploy the same infrastructure over and over again. At the start of my journey validating blockchain protocols, Luke Youngblood had a quote from Elon Musk that he mentioned in a talk that stuck with me "Build the machine that builds the machines". Over the years I have toyed with various different infrastructure provisioning automation from pure shell scripts to complex Terraform deployments.

With the release of a new network - Sui and the start of their testnet it seems like a good idea to build out the infrastructure deployment from scratch to help validators and full node operators while learning a new tool - Ansible.

This tutorial is to show the base structure to set up ansible to build the Sui program and configure a machine while showing the reader how the pieces intertwine. It will also act as an explainer of the key concepts of Ansible.

PR

https://github.com/0xzoz/sui-node-automation/pull/1

Tech/Product

Sui

Sui is a blockchain network that is being developed by Mysten Labs. Mysten Labs consists of some of the core engineers from Meta's defunct Diem/Move project, including the creator of the Move language. It is some of the most exciting tech in the blockchain space and is being built from the ground up factoring in the learnings from the development of Diem/Move. It also sets out to address some of the issues with the existing protocols and languages within the industry at present.

The platform claims to offer unprecedented low latency and scalability for straightforward use cases. This is achievable since the platform enables the capability of parallel transactions. Consequently, Sui can use processing resources more efficiently. With over $300 million in funding since its inception under a year ago, it is one of the most anticipated L1's to come out since Ethereum.

Ansible

Ansible is a software tool that provides simple but powerful automation for cross-platform computer support. It is primarily intended for IT professionals, who use it for application deployment, updates on workstations and servers, cloud provisioning, configuration management, intra-service orchestration, and nearly anything a systems administrator does on a weekly or daily basis. Ansible doesn't depend on agent software and has no additional security infrastructure, so it's easy to deploy.

It works by having a control node and managed nodes. The control node runs ansible and provisions the managed nodes. the control node sends modules to the managed nodes to execute via an ssh connection.

The best part is the composability of the platform allowing the user to package up multiple modules to be used in different applications. With the ability to connect your previously built legos, it drastically speeds up the development process and leaves little room for human error.

Scope

Because there is little information about validator operation and workflow in the Sui ecosystem at this stage, this PR is intended to be a base that can be built upon. Eventually, this will be a repository that any user wishing to run a full node, operate a validator, perform validator operations safely and monitor the node. All from a control machine with one-line commands.

We want this particular PR to allow a user to clone the repository, make a few minor changes and be able to deploy a full node with only one command. It will provision the target machine, build the Sui program and configure it as a systemd service and then start the service.

Subsequent articles will go into detail about running a validator, adding monitoring etc.

Commits

1. Add folder structure

   We want to add a folder structure that relates to the ansible framework. Below will show the outlined structure to help give context as empty folders do not show on git commits.

   ├── group_vars (keep the variables for items that will be used multiple times) 
   │   └── all
   ├── roles  (An ansible role is way to keep related files for a playbook together)
   │   └── sui_fullnode (our first role we will be working with)
   │       └── tasks (a place to store tasks, usually a file in tasks bundles related sub tasks)
   │       └── templates (a place to store templates of files to add to your target machine)
   ├── inventory.yml.sample (a basic inventory template with the key/values we need for our instance) 
   ├── LICENSE
   └── README.md
   

2. Add docs, sample inventory and license

   We want to add documentation to guide users cloning this repo on how to do a couple of items:

   • Configure their control machine

   • Set up ssh keys to connect from the control machine to the managed nodes

   • Create their inventory

   • Provision and start their node.

   We also want to add the sample inventory key/values that the user will want to copy and configure.

   Lastly, we will want to add a license to our repo that will allow this code to be forked and utilized by others. We choose the MIT open source license because we ❤️ OS and believe that software is a public good.

3. Add variables

   We want to add any common variables that we will be using across our sui_fullnode role(and eventually other roles) to a file within the group vars folder. We have added the all subfolder as these will be used across all the eventual roles we will create.

4. Add templates

   Ansible uses templates to create new files on the nodes using predefined models based on the Jinja2 templating system. Templates are commonly used to configure services based on variable values that can be set up on the playbook itself, in included variable files, or obtained via facts. This enables you to create more versatile setups that adapt behaviour based on dynamic information.

   Here we create two templates:

   • Sui fullnode yaml: We want to have the fullnode yaml file stored here to populate with our preferred config

   • Sui systemd file: We want to have a systemd that our playbook can use to create a systemd service for our node.

5. Add build task

   Now to the juicy stuff! These task folders bundle a specific set of sub-tasks(modules) related to the parent task. In this case, it is setting up our Sui environment and building the source(Sui is a spaceship so be prepared to wait while it builds 🚀). Ansible has two types of modules you can use for tasks - builtin and community. BuiltIn are maintained by ansible and you can expect them to be in working condition, community modules can be developed by anyone and should be reviewed before using them. Modules are a way to complete specific actions, an example would be downloading apt packages which would look like the following:

   - name: install apt packages required for building sui binary
     apt:
       install_recommends: no
       force: yes
       name:
         - curl
         - git-all
         - libssl-dev
         - libclang-dev
         - tzdata
         - ca-certificates
         - build-essential
         - pkg-config
         - cmake
         - acl   # needed to prevent errors when building as unprivileged user via become
       state: present
       update_cache: yes
   

   Here is the order of tasks we will be doing in this build document and the modules they are utilizing:

   • Create an unprivileged sui user - (user module)

   • Check if cargo is installed - (shell module)**

   • Download rust Installer - (get_url module)

   • Install rust/cargo - (shell module)

   • Update bashrc for rust/cargo for sui user - (lineinfile module)

   • Update apt-get repo and cache - (apt module)

   • install apt packages required for building sui binary - (apt module)

   • Check if sui is installed - (shell module) Note: notice the two different ways of using shell

   • Install sui - (shell module) Note: notice the two different ways of using shell

6. Add sui configuration task

   This file pulls the most recent sui repository from the devnet branch(not necessary but I added it anyhow) and configures your node with a fullnode.yaml file and the genesis.blob.

   Here is the order of tasks we will be doing in this build document and the modules they are utilizing:

   • Clone the SUI repo - (git module)

   • Creates fullnode directory- (file module)

   • Copy fullnode yaml file - (template module)

   • Get genesis blob - (command module)

   • Allow all access to tcp port 9000 - (ufw module)

   • Allow all access to tcp port 9184 for metrics - (ufw module)

7. Add systemd configuration task

   This will set up and start a systemd service to run the Sui fullnode

   Here is the order of tasks we will be doing in this build document and the modules they are utilizing:

   • Deploy /etc/systemd/system/sui.service - (template module)

   • Enable and start sui service - (systemd module)

8. Package in sui_fullnode role, configure tasks and populate root file

   We now want to tie all this together. We add the previous three tasks to a parent YAML file in the sui-fullnode role folder and we create the entry point for ansible in the root as main.yml. We should note that there are a couple of commented-out lines - Stay tuned for subsequent tutorials securing a server and adding a monitoring stack 👩🏽‍💻

Conclusion

This post should help you get familiarized with ansible and see how easy it is to create reproducible infrastructure. It will be a primer for more complex operations as the repository grows and we add validator functionality, add server security and implement a monitoring stack.

It may also act as an entry point to learning about Sui as a protocol or allow you as a node operator to have a more streamlined workflow. It's still very early days in the blockchain/web3/crypto space. Sui is likely to play a large part in developing the technology and scaling it to billions of users.

Stay tuned to hear about the next articles in the pull-requests-with-zoz series

This is one of many articles based on the concept of pull-requests-with-zoz

https://mirror.xyz/zoz.eth/WtdGWxlW1tLfujD4-SdhPwAFkMHcJNdwr-WIOG0xSxw

Cover Image

The image above(like my PP) is created with abraham.ai - an AI artwork generator

SEED: Automated Sui node

About

Twitter: @0xzoz

GitHub: @0xzoz

Mirror: @0xzoz

Discord: @zoz.eth#6952

ENS: zoz.eth

Precursor

In 2019(light years for the crypto industry), the crypto landscape looked very different. I was still around, but it was more of a goblin town than what we call goblin town today. Many 2017-era projects were either dead, pivoting, pivoting from a pivot or on their last legs! Around this time, I wrote one of my first articles. The seeds were sown in my mind from the birth of POS(Proof of Stake), being feasible and even implemented in a few early cases. The article was titled ”The Future of Work is not Work”. I wish I had tools like Mirror or Paragraph back then because after trying to search for the article, it appears I no longer have my Medium account, and it is lost forever. But the TLDR of the article was this:

Due to the new roles emerging around decentralized products, projects and protocols, we had to reimagine the typical role of working in everyday life. It would no longer make sense for people to work for a company the way we did for the last 300 years(more so 100 years with industrialization). It would not happen all at once and would likely slowly infiltrate as this generation loses its foothold to the new digital natives with a different perspective. An example used was that a user would contribute to a handful of diverse communities in various ways(left up to interpretation, but one was as a validator) as an alternative to going to the same office in the same company every day.

This may not seem too far of a stretch by today’s standards. However, before PoS, DAOs and NFTs were even in flavour with crypto natives, let alone front-screen news. It was also before Covid, the last bull run and Micheal Saylor buying up all the Bitcoin! With this series, I want to dive in and put some ideas about where we might be headed, what roles might exist and other musings about the future of work. Keep in mind might is the operative word here;. At the same time, I was able to transition into the exact role I mentioned in the paragraph above, it is currently a minute number of workers/entrepreneurs/jack of all trades, master of none types that are operating like this. Nothing is ever certain!

Content

• The Future of Work is not Work: spot saved for if I ever find the original article

• Opportunity Capitalist

• Onboarding(coming soon)

• Prompt Engineer(coming soon)

• Curator(coming soon)

• Mechanism Designer(coming soon)

Cover Image

The image above(like my PP) is created with abraham.ai - an AI artwork generator. SEED: The Future of Work is not Work

About

Twitter: @0xzoz

GitHub: @0xzoz

Mirror: @0xzoz

Discord: @zoz.eth#6952

ENS: zoz.eth

/ˌäpərˈt(y)o͞onədē/ /ˈkapədləst/

noun

noun: opportunity capitalist; plural noun: opportunity capitalists

An individual who, instead of working a traditional job, spends time contributing to decentralized protocols/projects/products to gain equity/skills/relationships. An iteration of the VC but at a smaller meaningful scale that is not purely return motivated.

Venture Capitalists Sowed the Seeds

There is no doubt that Venture Capital fueled the industrial age allocating capital to long shots that reaped rewards, changed the fabric of society and shaped our day-to-day lives. Let’s dive into how we got to the present-day venture firm, how it differs from the original implementation and a brief timeline. This will lead us to some of the next questions and predictions.

What is Venture Capital?

It’s a form of private equity. The equity is secured from liquidity providers(wealthy individuals and corporations) and used to fund early-stage projects(start-ups) after the seed stage. These ventures are usually high risk and high reward with a low efficacy rate. It is a mutual agreement between the founders of the project and the VC firm, the founders would often not be able to scale without the funding and support. The VC firm's business is based on a certain percentage of its bets will be extremely successful and go to the IPO stage where they can exit to secure the gains. Rinse and repeat.

History of Venture Capital

Originating in the early 1900’s it was nothing like it is today. The majority of the population did not have the capital, information or resources to participate in the above description. It was the very wealthy individuals and families who created these investments. The next cohort of Venture Capital came after World War II(~1945). George's Doriot is termed the "father of venture capitalism" and founded ARDC in 1946 to encourage private-sector investment in businesses run by soldiers returning from World War II. This kicked off the next era of innovation, although the structure was more like a public company compared to the VC firms that exist today. This cohort fertilized the seeds that grew into separate spin-offs and morphed into a variety of different models.

Timeline

├── Early 1900's : Wealthy inividuals & familys
│   ├── J.P. Morgan
│   └── the Rockefellers
│
├── 1945 : American Research and Development Corporation
│   ├── Georges Doriot
│   ├── Ralph Flanders
│   └── Karl Compton (former president of MIT)
│
├── 1958 : Small Business Investment Act of 1958
│   └── The Small Business Investment Act of 1958 provided tax breaks that helped contribute 
│       to the rise of private-equity firms
│
├── 1960s : venture capital came to be almost synonymous with technology finance.
│   └── The Firms were primarily focused on companies were exploiting breakthroughs in electronic, 
│       medical, or data-processing technology 
│
├── 1970s : growth of the venture capital industry was fueled by the emergence of the independent investment firms 
│   ├── Kleiner Perkins
│   └── Sequoia Capital
│
├── 1973 : leading venture capitalists formed the National Venture Capital Association (NVCA)
│
├── 1980's : From just a few dozen firms at the start of the decade, there were over 650 firms by the end of the 1980s
│
├── 1990's : World Wide Web
│   ├── Netscape and Amazon (company) were founded in 1994, and Yahoo! in 1995. Each funded with venture capital
│   └── The Exit: Internet IPOs—AOL in 1992; Netcom in 1994; UUNet, Spyglass and Netscape in 1995; Lycos, Excite, Yahoo!, 
│       CompuServe, Infoseek, C/NET, and E*Trade in 1996; and Amazon, ONSALE, Go2Net, N2K, NextLink, and SportsLine 
│       in 1997
│   
└── 2000 : The Dot Com Crash

Today

As you can see, reading this now and using this network of networks. The internet did not die, it grew into a vast luscious forest where any person could become a VC with a LinkedIn profile and acronyms that a PHD has never heard of:

With the flood of venture capital owning non-trivial stakes in what we call Crypto or Web3, what originally was the gasoline for the fire may have sucked the oxygen from the room. Arguably the model just changes, or there may be room for a subset of Venture Capital. The argument is that capital is no longer the scarce resource that a product/protocol/project needs.

Is a Network a Business?

Why was the preceding section so important to the concept we introduced in the title? Without knowing how our lives were built by a sea of capital, the most valuable resource at the time. We may not have the context we need to see the similarities between early company formation and how it compares to early network growth in the present. From wealthy elites to tens of thousands to around a million today, this shows the idea of venture capital scaled to the masses, and it scaled because there was an ever-growing amount of companies being built. Mostly due to technological innovation as we saw from the 90s until now. With every stage of innovation, there is a cross-over from the old to the new that overlaps and is not as efficient as it could be but with time, it is optimized.

As we are seeing by the information barrier being removed with the internet coming of age, there are coordination abilities sprouting to life that couldn’t have been possible only a decade before. While networks have always existed, the internet taught us that they could be managed at a global scale by clusters of nodes.

Companies, in general, operate very well with their hierarchical structure and processes. For the majority of the last couple of centuries, this has been the most efficient way a business operation could exist. Notwithstanding the downfall of bureaucracies today(a story for another time) and the bloat they now endure, companies have their place in the world of today and yesteryear but will a better option be available soon? It depends on the context.

Networks were missing one key attribute to become a vehicle for groups to coordinate in the same way that a company operates. While they were much more nimble and resilient than a company, they lacked the important necessary ingredient ‘value’. Particularly natively packaged trustless transfer of value between the different nodes within the system. In the last 10 years, this has become increasingly available. First with Bitcoin, then with smart contracts and now the products being built around these valuable primitives.

This is now the golden era of experimentation, iteration and invention of what is possible with these new tools to coordinate and operate between nodes or entities spanning continents. We have only just touched the surface of what is possible. We now have a large number of Venture Capitalists, debatably the majority of them merely providing capital coupled with an explosion of ideas from an ever-growing pool of entrepreneurs. If a network is now suitable to be a vehicle for a business and there is an abundant supply of the former two. What is the real scarce resource?

We don’t need Loggers and Logging, We need Fertilizers

There’s now a gap opening between the end user and the business vessel that we call a network. Let’s start with what a network needs; First and foremost, it needs a reason to exist. Be it a decentralized state machine, a more efficient way to distribute trustless value or simply to exchange dog pictures(or coins). It needs infrastructure, it needs people using it, and it needs a community of individuals with a purpose. Money can only buy a certain amount of this for a limited amount of time before reality starts to seep through the cracks.

What will not be as obvious today as in hindsight is when the fog clears that the ecosystem within a network, the roots, the passionate individuals and the presence is what fuels it. Without it, there is just a piece of technology left by the wayside after the funds are extracted. Like a hole in the ground of a decommissioned gold mine. Speaking of such.

A story comes to mind of a small gold mining town. On Alta Mountain within the Little Cottonwood Canyon in Salt Lake City, Utah, During the early days, the sawmills operating at Alta required vast amounts of logs. Trees were felled in such great numbers that the slopes were practically denuded of timber by 1884. With the removal of the trees, there was little to hold back the accumulated snow. During the winter of 1873-74, a disastrous snow slide swept down from the mountain and destroyed about one-half of the town. Sixty persons reportedly lost their lives in the main blocks of the town. A fire followed the avalanche, and between the two destroyers, the town was almost completely wiped out. Other avalanches and fires swept through the town in the following years. In 1885 a slide swept down from Rustler Mountain, partially destroying the town. This history acts as a metaphor, a story about greed, unfamiliarity and lack of thoughtful foresight that resembles what we might be seeing now within these networks. This is for good reason, what seemed like fiction only a couple of years ago is now a small ecosystem within the forest VC created. What this means is there is an opportunity to fill the gap between the extreme event of failure and death that is resonant in the early days of the venture as it grew away from wealthy elites and before it became what it is today.

The Opportunity

Opportunity exists in this gap. We are now seeing a shift where a role is emerging out of necessity. After the dust began to settle in 2019 after the crash of early 2018, to the foreign bystanders it looked like “that whole crypto thing” had been a fad. Undeniably it even looked that way to lots of passengers still aboard the 2015,16,17 bus as the seats emptied during 18/19. But many seeds were starting to sprout with one thing missing - believers, skills, and passionate individuals to use those skills. While the majority of the initial building was done by regular employees and founders, similar to existing early-stage ventures. They needed new roles like Validators, Community Mods and Builders to build upon the networks that were being designed and constructed. During that time, Zaki Manian designed one of the few ecosystem growth campaigns designed to recruit, train and eventually employ(not in the traditional sense) - The Incentivized Testnet. It would allow any individual to permissionlessly enrol and join a game based on the operation of running validator nodes to protect the network being built. It may seem strange reading this now but similar to mining Bitcoin way back in the day, you could barely find enough people to join the testing phase. Because now, with the hindsight of seeing the value of the networks(In physical, philosophical and by value), it is a no-brainer. The equity earned by participating in these early games allowed the participants to own a meaningful stake in the network.

This was the beginning of these types of opportunities. We started to see other such examples, like early digital art collecting with the narrative of unique scarce timestamped sealed packets of data(NFT’s) and working group roles within DAO’s. Notably missing is farming, While an innovation in mechanism design for the time, this does not fall into the same category as above because it was a somewhat different breed of user who ultimately extracted value with this endeavour. It was one who was versed in the knowledge barrier of the next participants.

The Opportunity Capitalist is what a network needs. They are defined by values and are involved in jumpstarting these networks for learning, ideals, equity share and for the improvements they provide compared to previous and current systems. Monetary gain is a secondary motive, most value accrues from the journey. Networking and training are just as valuable due to these skills not being defined or available when acquired. This insight gives skills and knowledge that compound and leads to future opportunities. It should be noted though that this is not scalable by design. To give meaningful value back to the network, like any social network, is the capability for a single person to nourish relationships and provide their most valuable assets - attention and time. Realistically the individual becomes ineffective after around 5 networks and neutralizes the value for each one added to the attention list, at worst, it is destructive to their presence within the other networks.

Due to the value being time and attention instead of capital. These networks naturally grow and overlap these opportunity capitalists even though the immediate breath is small, have an exponential effect due to the overlap between nodes within the multi-layered mesh

This is the real hyperstructure being built. The one that will sew the fabric of our digital lives, products and relationships together. While this role was essentially created in 2019 while the ecosystem is a very unique subset of participants, over the last few years we have had a change within the idealogy of new participants. They come from TradFi (traditional finance), and startup world and bring with them the processes and organization. Trying to inadvertently coerce these networks to fit a mould of familiarity. This may not be the approach that will drive these networks forward and could be detrimental to Opportunity Capitalists.

We now enter the do-or-die stage of the OC, do traditional values overthrow the progress being made using traditional resumes filled with buzzwords and political correctness OR do we step outside our comfort zone and have anons with a track record of soul-bound achievements to take the reign? Likely somewhere in the middle.

Home Sweet Home

Although nomadic by nature, OC’s need a home and there are a couple of prerequisites that must be considered:

Credible neutrality: the home must be agnostic as tribalism is ever prevalent in most networks. Strong values but open to ideas.

Organic: there must be no foundation, investors, SAFTs. The network had to have been built by contributors because they shared a vision, not due to incentives provided by another entity higher up the pyramid.

while there may be a multitude of projects that fit these needs, it’s hard to find them due to the nature of ideals and lack of easy capital. Canto and 0L are a couple of examples of such networks.

I would love to have your opinion about this concept!!! Please reach out and let me know. This is part of the-future-of-work-with-zoz series

Cover Image

The image above(like my PP) is created with abraham.ai - an AI artwork generator SEED: opportunity capitalist

About

Twitter: @0xzoz

GitHub: @0xzoz

Mirror: @0xzoz

Discord: @zoz.eth#6952

ENS: zoz.eth

This is a three-part series in the larger pull-requests-with-zoz series:

Easy - Adding an injected provider to an existing library

Medium - Adding an integration of a wallet

Hard(this) - Adding a wallet as a package to an existing library

Motivation

When starting to contribute to the open-source community-run browser wallet Tally Ho by integrating it with products, I didn’t know much about how a crypto wallet is integrated with dApps. Having spent numerous hours helping the team and community, I now have a better understanding of what is technically happening and how it can be done in the best way possible to help with not only connecting to an application but also strategically providing the tools for others to help brand awareness and visibility.

This article breaks down how to integrate a wallet with a wallet library by creating a separate package that’s loosely coupled to the library to provide more composability. Tally Ho had originally been integrated into Web3Modal as an add-on to the injected provider slot, which the library uses to bundle the common wallet type together. Generally, this works by identifying the current extension browser and connecting to that. For example, if you have MathWallet installed instead of Metamask, the injected option would show the MathWallet logo and name on the button, and it would connect seamlessly.

Due to the early stage nature of Tally Ho as a project and the roll out of features compared to other more established wallets, it was generally used alongside another wallet. This did not provide the best user experience. To remedy this, we change the current implementation and implemented it as a package. I went over the first integration in the Wallet Integration: Easy article in this series if you would like to check it out.

PR

https://github.com/WalletConnect/web3modal/pull/571

Tech/Product

Tally Ho

Tally Ho is an Open Source Community run Web Browser Extension Wallet. Wow, that's a mouthful! What exactly does that mean?

Necessary Backstory: The largest wallet in space is Metamask. While once a grassroots endeavour, with the growth of crypto as an industry, MM’s user base also grew - massively! MM is owned by Consensus, and they have investors who they have to please. This led to the wallet creating a revenue-generating feature: the ability to do token swaps natively in the wallet(for a generous fee, of course). Around this time, MM also changed their license so others could not use their code(not very web3-like).

Tally Ho is an initiative to do exactly the opposite. Create a wallet that is built, owned and used by its users. It’s open source so you can fork the crap out of it, but most importantly, the value accrues back to the users. It is the essence of web3 and proves that we can do good!

Web3Modal

This is one of the most used wallet libraries within the industry. Web3Modal is an easy-to-use library to help developers add support for multiple providers in their apps with a simple, customizable configuration.

By default, Web3Modal Library supports injected providers like ( Metamask, Brave Wallet, Dapper, Frame, Gnosis Safe, Tally, Web3 Browsers, etc) and WalletConnect. You can also easily configure the library to support Coinbase Wallet, Torus, Portis, Fortmatic and many more.

Scope

To change the existing Tally Ho wallet integration from an add-on to the injected provider package and separate it out into its own package. The reasoning for this is 3 fold:

1. Due to a change in the Tally Ho code injecting Web3 into the browser, the original integration broke, and the Tally Ho logo would no longer show. The wallet would still connect, but this didn’t really jive with us.

2. You needed to set Tally Ho as the default wallet in settings if you had other browser wallets alongside Tally Ho. Again, this is a really bad UX, and we could do better

3. Due to the collaborative nature of the Tally Ho story and being a community-run open-source wallet, products want to have Tally Ho as an option, even if the user does not have it installed, to create brand awareness.

With a new understanding of the best way to implement this and the above user issues, we wanted to address them. Let’s break down what we did. You can always look through the other articles in this wallet series for higher-level explanations if some of the points below don’t quite make sense.

Commits

1. Renaming for latest brand change

Since the initial PR integrating Tally Ho there was a name change due to some conflicts with the name Tally instead of Tally Ho. This commit corrects the naming to represent Tally Ho before we make further changes.

1. Add additional check to capture Tally Ho instead of fallback wallet

Because of changes within the Tally Ho codebase and injecting Web3 into the window(see 1. above), we need to factor in that Tally wants to be noticed instead of being overridden by the fallback wallet(web3). A simple check is added to the logic that checks if Tally Ho is identified and if Web3 is identified. This will give Tally Ho precedence over the default.

1. Use window.tally to make Tally Ho dominant wallet when installed

Tally Ho uses two different methods to inject into the window object. Firstly injecting Tally(eg window.Tally) directly into the window object allows it to be detected and used at all times. Secondly, if the ‘set as default’ option is checked in the settings. Then Tally Ho mimicks Metamask by also injecting it into the Ethereum object in the window object (eg window.ethereum) and can be checked via window.ethereum.isTally field. Because we want to allow Tally Ho to be recognized and used alongside other extension browsers. We refactor the package to use the window.tally method.

1. Add Tally Ho provider

We need to add a custom provider for Tally Ho to be able to use a couple of Tally Ho specific packages:

- tallyho-detect-provider - tallyho-onboarding

This new provider will make sure that Tally Ho is not using the standard injected provider if the product using Web3Modal specifically sets Tally Ho as a separate slot.

1. Allow Tally Ho to be interchangeable either as injected or as a provider option

Because we want this change to be backwards compatible and also allow products that do not add Tally Ho as a package to be able to have Tally Ho as an injected provider. This requires a couple of changes.

- A check in src/helpers/utils.ts (L182) to set the injected value to Tally Ho if the package is not installed and if Tally Ho is installed

- Change the name of the Tally Ho injected instance to be able to be used for the package as well

- Change logic ordering in src/providers/connectors/injected.ts

- Instead of just console logging in src/providers/connectors/tallyho.ts throw an error to exit the operation.

1. Add documentation

Add the relevant documentation to capture the changes that were incorporated into this PR.

Conclusion

We end our wallet series here by adding a wallet package into a library. The skills you have learnt over the last 3 articles more than provide you with the ability to contribute to a DAO and open source protocol. Hopefully, this gave an understanding of wallets and their interaction with the browser and web applications.

We at Tally Ho need contributors to help integrate with other projects. If you would like to join the pawdnership team, please reach out. We are also happy to help mentor keen enthusiast individuals!

This is one of many articles based on the concept of pull-requests-with-zoz

https://mirror.xyz/zoz.eth/WtdGWxlW1tLfujD4-SdhPwAFkMHcJNdwr-WIOG0xSxw

Cover Image------------------------------------------------------------

The image above(like my PP) is created with abraham.ai - an AI artwork generator SEED: zoz.eth integrating a dog wallet with a blockchain network using easy mode

About-------------------------------------------------------------------

Twitter: @0xzoz

GitHub: @0xzoz

Mirror: @0xzoz

Discord: @zoz.eth#6952

---------------------------------------------------------------------------------------

ENS: zoz.eth

Motivation

I had originally heard about Ceramic from a podcast. The concept of having a data model standard within Web3 made a lot of sense. This concept took a while for me to grasp technical concepts of how to make that magic actually happen but I documented it here so it is easier for you. When I saw a Gitcoin bounty to integrate this tech with Superfluid I knew it was the best opportunity of learning firsthand if there was substance to my intuition.

PR

https://github.com/superfluid-finance/superfluid-console/pull/93/commits/b1ac01fb3c866ddc7442059d0f566fdfe92482c8

Tech/Product

Ceramic

The website describes it as: “Ceramic is a decentralized data network that brings unlimited data composability to Web3 applications.” but what does that mean exactly, and why should you care?

Ceramic acts as a platform to store your user’s data and create standardized data models that, once adopted and reused by the industry, will allow the next layer of composability within Web3 and Defi. It uniquely allows the user to own their data using their DID(persistent decentralized identifier) that can be generated in many ways, but in this case, using the user’s crypto wallet.

It works by creating streams for data models that are then available for users using their DID. You can think of it as a data table, your DID is the row, and each stream created is a column. An example might look like the one below:

Superfluid

Imagine a world where value can be distributed in real-time at any interval and determined individually for the use case. Powerful, easy and one of the simplest product market fit for blockchain and crypto. Well, Superfluid is just that, a streaming service building block that can be used modularly with other products. But what good is this without a way to visualize that data in real-time across each of the networks superfluid is deployed to? In comes superfluid console - A way for users to do just that. It would be nice if this was using a common framework for the data so it could be even more composable in the ever-growing Defi ecosystem, wouldn’t it?

Scope

What we wanted to do in this PR is marry the two technologies while incubating the design of an Address Book Data Model to track a user’s connected wallets and their streams. Creating this would allow it to be packaged and stored decentrally on Ceramic while accessible to other applications that could leverage the existing model.

There are two parts to getting this completed.

1. Creating the Data Model and deploying it to the Ceramic registry. We covered this in a previous blog post.

2. Using the already available DID on ceramic to connect with Superfluid. Then creating the ability to add, edit and retrieve Address Book data to be used within the Super Fluid console.

Commits

Unfortunately this PR was completed before the concept of pull-requests-with-zoz was conceived and it was done with one large commit(Im now starting to expose just how little I knew🤦🏼). For purposes of this article we will breakdown this large commit into steps like it should have been done.

Let’s first break down what needed to done. I had no previous exposure to either Ceramic or Superfluid so I had to get a grasp of how these applications work. Ceramic was a large learning curve and my first post breaks it down for a dummy like me. Secondly, I really didn’t know how Address Books worked in the console and it took me a long time to even find where to add an entry(not a great user experience, but its Web3 so we will give it a pass - for now). With that said and maaannnny more hours than I should have spent. I determined I needed 4 pieces added:

• Add the necessary packages, and references to the data models and wrap the app in a provider.

• A button to connect to ceramic and recognize the user’s identity

• A neat way to package the interactions a keep them separately contained - maybe a React hook

• Replace the existing interactions with the applications state and use the newly created methods in the above step to instead use the new Data Model and interact with Ceramic.

Don’t worry the next steps will help describe and allow you to visualize this better if it doesn’t make sense.

1. Determining where the changes need to be made

This is always the biggest hurdle when trying to grasp a new concept and multiple products with different codebases. There is no shortcut. You must read the code, break things, and insert a billion console logs(well at least I do). I usually create a separate branch just to do this and use it as a messy draft of what I will actually submit as my final PR.

2. Add the necessary packages, and references to the data models and wrap the app in a provider

I suggest reading the first Ceramic post as this explanation will be briefer(with the assumption you have a little more knowledge than I did when I started). We will need two packages:

- @glazed/types: This will be used to give a defined structure and connect Data Models with aliases - @self.id/framework: This is a powerful wrapper that encaptures all the functionality of the Ceramic protocol into a neat package.

We want to wrap the application in the Provider(src/pages/_app.tsx - L66) and add our references to our Data Models(src/utils/ceramicModel.json to use later on. Where did we get these references from? We created and published them to the Ceramic network. We also could have got them from the Data Model Registry if they had been published previously.

3. A button to connect to ceramic and recognize the user’s identity

We will go ahead and create a new React component of a Button(src/components/CeramicConnect.tsx) that will allow us to log in and get our identity. *Note: the button will be using our React hook we create in the next step

The button performs a couple of functions: Connect, Disconnect with the @selfId framework(L11 - L28) and also gets our DID. It is using our Ethereum address from our injected wallet to recognize us.

4. Package the interactions in a React hook

Let’s first understand what a React hook is. A hook is a collection of functions that isolate the stateful logic to use within other components. That is any variables that need to be changed and managed. In this instance we would like to manage the Ceramic state. This article is helpful to give a more in depth explanation of hooks.

Here we create the useAddressBook hook and it is found in the src/hooks/useAddressBook.ts file. This hook is to manage the addressBook state within the Superfluid Console application so we want to bring in some other dependancies here like:

• useViewerConnection from the @self.id/framework.We want to use this as it will get our current connection to Ceramic

• Standard useAppDispatch and useAppSelector react hooks. Also the useCallback hook. These will help us interact with our application state and the app

• useViewerRecord from the @self.Id/react library. This will help us pull data from Ceramic by giving it an alias

Now we just want to create reusable functions within the hook that will help us achieve our task of creating, updating and deleting the data within ceramic. The functions between lines 29-87. The two functions below that are just a way to massage and transform the data in and out.

5. Replace the existing interactions with the applications state and use the newly created methods

Wow… Not really that much to it when its broken down and explained is there? On to our final boss… Connecting it in to the existing application and wiring it all up. This happens in the src/components/AddressBook.tsx file. This file was already doing much of the functions we need but it was using the state in react and on the client. So essentially we just refactor these existing functions. We need to bring in the following items:

• useViewerConnection and useViewerRecord from @self.id/framework

• And of course our new useAddressBook hook

When we bring in addAddressBookEntry and removeAddressBookEntry from useAddressBook we can now replace actions with these.

We also want to let the user know they need to connect to Ceramic to use this new functionality if they have not already. This is done by checking if we are connected and showing a warning if not. This happens between lines 111-120.

There we go!!! YOU now have the knowledge to integrate Ceramic with your favourite applications

Conclusion

This post first serves as an example to what not to do in a PR by showing a poor monolithic approach of using one large commit. But also providing a solution to how it could be done better. These are the commits I would do now if I was to integrate another application

Ceramic is a powerful tool that will only get better as more integrations use the network. How I view it is like an interoperable data service that is blockchain agnostic. A new model for any application, not even blockchain to leverage. The intention of this post is empower even a novice like myself to integrate and use Ceramic. It also breaks down just how easy it is!

This is the first of many articles based on the concept of PR’s with zoz

https://mirror.xyz/zoz.eth/WtdGWxlW1tLfujD4-SdhPwAFkMHcJNdwr-WIOG0xSxw

Cover Photo-------------------------------------------------------------

The image above(like my PP) is created with abraham.ai - an AI artwork generator SEED: zoz.eth integrating a Ceramic Data Model into the Superfluid console

About-------------------------------------------------------------------

Twitter: @0xzoz GitHub: @0xzoz Mirror: @0xzoz Discord: @zoz.eth#6952 ---------------------------------------------------------------------------------------

ENS: zoz.eth

Cover Photo-------------------------------------------------------------

The image above is created with abraham.ai - an AI artwork generator

SEED: zoz.eth

About-------------------------------------------------------------------

Twitter: @0xzoz

GitHub: @0xzoz

Mirror: @0xzoz

Farcaster: @0xzoz

Discord: @zoz.eth#6952

---------------------------------------------------------------------------------------

This is a three-part series in the larger pull-requests-with-zoz series:

Easy(this) - Adding an injected provider to an existing library

Medium - Adding an integration of a wallet

Hard - Adding a wallet as a package to an existing library

Motivation

This is where my journey started 😁. I was a wannabe blockchain developer that lacked knowledge and had never written a single line of open source code. I was inspired by a user(@commstark) on the Tally Ho Discord who had started contributing to the project and created a team of helpers doing non-technical tasks. Tally Ho had just started their Pawdnership Pack initiative to get developers helping to integrate the wallet with as many products as possible. I thought, why not, what did I have to lose? This is not that actual first PR, in fact, that was very simple(one line of code lol) but from that, I was able to piggyback on the success and the knowledge it gave me. I want to make this public to help others take the first step.

PR

https://github.com/WalletConnect/web3modal/pull/389

Tech/Product

Tally Ho

Tally Ho is an Open Source Community run Web Browser Extension Wallet. Wow, that's a mouthful! What exactly does that mean?

Necessary Backstory: The largest wallet in space is Metamask, while once a grassroots endeavour, with the growth of crypto as an industry, MM’s user base also grew - massively! MM is owned by Consensus and they have investors who they have to please. This led to the wallet creating a revenue-generating feature: the ability to do token swaps natively in the wallet(for a generous fee of course). Around this time, MM also changed their license so others could not use their code(not very web3-like).

Tally Ho is an initiative to do exactly the opposite. Create a wallet that is built, owned and used by its users. It’s open source so you can fork the crap out of it but most importantly, the value accrues back to the users. It is the essence of web3 and proves that we can do good!

Web3Modal

This is one of the most used wallet libraries within the industry, Web3Modal is an easy-to-use library to help developers add support for multiple providers in their apps with a simple customizable configuration.

By default, Web3Modal Library supports injected providers like ( Metamask, Brave Wallet, Dapper, Frame, Gnosis Safe, Tally, Web3 Browsers, etc) and WalletConnect. You can also easily configure the library to support Coinbase Wallet, Torus, Portis, Fortmatic and many more.

Scope

To allow Tally Ho to connect to applications when they are using the Web3Modal library. It is important that the Tally Ho logo shows as we want users to have a familiar experience when connecting to the app. This is a pretty simple addition seeing as the wallet library treats all injected providers as a single package and is compostable. Lets spend some time discussing how this actually works to better understand how a wallet is interacting with our browser

The What and How of a Provider

A provider is an API the wallet injects into the window object on your local browser. Once installing a wallet like Tally Ho it does this by default. Tally Ho is different from other wallets but we will get into that below. Let’s use Metamask as this example to help build the concept. MM and most web3 wallets inject a global API in the window.ethereum object and this allows websites and dapps to do the following:

• Detect the Ethereum provider (window.ethereum)

• Detect which Ethereum network the user is connected to

• Get the user's Ethereum account(s)

Here is a snippet of code to help you visualize the above statement

// usually this is encompassed in a if statement checking we have a wallet installed

if(window.ethereum){

   const provider = window.ethereum;
   startApp(provider); // initialize your app
     
} else {

   console.log('Please install Wallet!');

}

The presence of the provider object indicates an Ethereum user. We won’t go too deep but this global object acts as a gateway. Some highlights of the features:

• provider.isMetaMask - Each wallet has its own variation(provider.isTally) but this allows you to check the wallet currently installed and active.

• provider.isConnected() - Check if the application is already connected.

• send events - eg provider.on('connect', handler: (connectInfo: ConnectInfo) => void);

Hopefully, this should help with the basic building blocks to understanding how an injected wallet is interacting with your browser.

How is Tally Ho Different?

Unrelated to the overarching concept but provides some context for future pieces in the wallet integration series.

Tally Ho knows they are the underdog(pun intended lol). They need to be able to allow devs to connect in any way possible. While also not impeding the experience of having multiple browsers installed as it scales and before it has the full war chest of features we Web3 natives need.

The wallet does this in two ways:

• Allowing users to set the wallet as default in the settings. This then injects the window.ethereum object that you could use window.ethereum.isTally and it would return true. If it is not set to default and another wallet was installed, that wallet would now take precedence. This helps provide Tally with ease of integration while leveraging existing infrastructure.

• Tally Ho also injects the window.Tally object to allow it to act as a stand-alone wallet alongside other injected providers and empowers developers to be able to use say Tally Ho and Metamask and connect separately.

Commits

1. Add Tally as an injected option

This adds a couple of items. A image to use when the library recognizes Tally Ho as an injected provider. Also added is the standard IProviderInfo type into the src/providers/injected/index.ts file with the Tally configs set. The /injected/index.ts file houses all of the injected providers and some other logic loops through to see what one is connected. The logic is not necessary to dive into now but post 3(Wallet Integration: Hard) in this wallet integration series explains it more in depth

1. Add Tally to documentation

This commit simply updates the documentation to allow devs to know that Tally Ho is integrated within Web3Modal.

Conclusion

While helping work on Web3 apps may seem daunting at first. This wallet integration helps to break down how easy some of these features can be to add. An integration like this is a great way for a relatively small piece of work to provide an exponential amount of value due to the library already being integrated with numerous DApps. Every time one of the DApps updates to the version this change was introduced Tally Ho is able to connect.

This is one of many articles based on the concept of pull-requests-with-zoz

https://mirror.xyz/zoz.eth/WtdGWxlW1tLfujD4-SdhPwAFkMHcJNdwr-WIOG0xSxw

Cover Image------------------------------------------------------------

The image above(like my PP) is created with abraham.ai - an AI artwork generator SEED: zoz.eth integrating a dog wallet with a blockchain network using easy mode

About-------------------------------------------------------------------

Twitter: @0xzoz GitHub: @0xzoz Mirror: @0xzoz Discord: @zoz.eth#6952 ---------------------------------------------------------------------------------------

ENS: zoz.eth

If you are a seasoned dev you can skip this. Believe it or not, it actually took a long time for me to figure out how to contribute to open-source projects. I wanted to use this as a primer and as a reference to send to people when they inevitably ask ‘What is a PR?’ or ‘How do I create a PR?’

Introduction

A pull request is how a developer can add changes to a codebase using a version control framework. In open source communities, a pull request is like a welcome handshake, it will determine first and foremost if your code will be added to the repository and will leave an impression on the other contributors who will decide if they would like you to contribute to future work. These are some items I wish I knew before diving head first!

Terms

Open Source: Open source means anybody is free to use, study, modify, and distribute your project for any purpose. These permissions are enforced through an open source license.

Version Control: Version control is a system that records changes to a file or set of files over time so that you can recall specific versions later.

Repository: A Git repository is the .git/ folder inside a project. This repository tracks all changes made to files in your project, building history over time. Meaning, if you delete the .git/ folder, then you delete your project’s history.

Branch: a branch is a new/separate version of the main repository

Commit: Adding commits keep track of our progress and changes as we work. Git considers each commit change point or "save point". It is a point in the project you can go back to if you find a bug, or want to make a change

Git: Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency.

GitHub: GitHub is a code hosting platform for collaboration and version control. A GitHub repository can be used to store a development project. You can think of it like a UI for Git.

Fork: Forking is creating a clone of the current repository.

and of course ⬇️

What is a Pull Request

When a group of people are contributing to a development project, to keep the main code that is operational clean and working, there is a standard set of rules that takes place. We will simplify this a lot for brevity and to help give context to our goal - Creating our first PR

When we would like to add a feature or fix a bug in the production code(main branch) these are the steps we follow:

• We create another branch

• Write our changes

• Test

• Merge back into the main branch

Creating your First Pull Request

I learn by doing so I have set up this interactive tutorial to get you creating your first PR. You can find the Repo here and feel free to comment, ask questions and interact as much as you would like.

This tutorial assumes that you have a Github account, VSCode installed and know what the terminal is. If you feel setting up your environment would be a useful article drop me a message.

1. Fork the repo by going to this [link](https://git clone https://github.com/0xzoz/pull-requests-with-zoz.git) and clicking the fork button at the top right

2. Clone the pull-requests-with-zoz repogit clone https://github.com/<your-username>/pull-requests-with-zoz.git

3. Create a new branch to add your changes git checkout -b add-new-name

4. Navigate to the root(the top-level directory in a folder structure) and there will be a file named Letsgooooo.md. Open it and add your GitHub handle( eg @0xZOZ) and a sentence.

[//]: # (letsgooooo.md) 

Welcome to PR's with zoz. Hold your breath, you are about to create your first PR. 

@0xzoz - I made it!!!!
@your-username - You made it!!! // this is new code that you will add

5. Add and Commit the code to the branch

git add . - This is adding all the changes that have been made within the repository

git commit -m ‘Add yourname to file’ - This stages all the changes to the current branch with a message about those changes.

6. Push the changes and branch to Github. git push

this will result in an error and will give you a command similar to the following because it is the first time you add the branch to the repo

git push --set-upstream origin add-zoz

7. Navigate back to your forked repo. You should now see a little banner at the top of the page like this

8. There is a template that will be similar to what you see when you are contributing to open-source projects. Take note of the branch you are merging into eg you want to merge the add-zoz branch into the main branch

Congratulations!!!! You just submitted your first PR. I hope this helped you get started, you are now ready to start diving into the pull-requests-with-zoz series

What is the pull-requests-with-zoz series?

This series is for the curious potential web3 coders out there. I, like you, started with a vision that blockchain and web3 will change the world yet I didn’t have the skill set to actively help build that world we so long for.

pull-requests-with-zoz will help anyone of any skill set learn about a product, project or discipline in a new content form I felt would be beneficial for others. It consists of two complementary pieces:

1. A pull request that was contributed to an open source crypto project

2. An article explaining the what, why and how.....

The series will be in no specific order but as more PRs get completed, the collection will be bundled into focused groups as the content grows.

Breakdown

Each article will have the following structure:

• Motivation

• Tech/Product

• Pull Request Reference

• Scope

• Breakdown of commits

  • What is happening in each one

  • Why design decisions were made

  • Issues

• Conclusion

Why

I started developing open source software with not much knowledge. It was a huge step to be able to send my first PR(one line of code lol). With each PR, I get a little bit better at understanding these new technologies. While it takes me more time than it should. If I can give back to help others understand concepts faster. It makes me feel like those extra hours were worth it.

These are for me as much as they are for you. I am by no means an expert and writing these down for others helps me grasp the concepts. There will be errors but there will also be valuable gems that will help breed the next cohort of everyday cypherpunks trying to change the world.

Learn how to send your first pull request and how the pull-requests-with-zoz series will guide you through some pull requests to open source Web3 projects

https://mirror.xyz/zoz.eth/WtdGWxlW1tLfujD4-SdhPwAFkMHcJNdwr-WIOG0xSxw

Cover Photo-------------------------------------------------------------

The image above(like my PP) is created with abraham.ai - an AI artwork generator SEED: zoz.eth sending a pull request

About-------------------------------------------------------------------

Twitter: @0xzoz GitHub: @0xzoz Mirror: @0xzoz Discord: @zoz.eth#6952 ---------------------------------------------------------------------------------------

ENS: zoz.eth

The website describes it as: “Ceramic is a decentralized data network that brings unlimited data composability to Web3 applications.” but what does that mean exactly, and why should you care.

Ceramic acts as a platform to store your user’s data and create standardized data models that, once adopted and reused by the industry, will allow the next layer of composability within Web3 and Defi. It uniquely allows the user to own their data using their DID(persistent decentralized identifier) that can be generated in many ways, but in this case, using the user’s crypto wallet.

It works by creating streams for data models that are then available for users using their DID. You can think of it as a data table, your DID is the row, and each stream created is a column. An example might look like the one below:

Motivation for this Article

I set out to learn ceramic and how to integrate it into an application after two things happened. Firstly, I heard Kyle Samani(investor at MultiCoin Capital) mention the platform on Epicenter and secondly, I saw there was a bounty to connect a ceramic data model into the Superfluid Console for Eth Shanghai hackathon.

I started with the best intentions, but apart from the documentation available via the Ceramic website, there were not many tutorials from contributors. I found it hard to navigate the documentation to see what I wanted to do. The team is currently reworking some of the documentation. This is by no means a criticism of the team and the work done; they are big brains and have made fantastic docs to match their state-of-the-art protocol. This tutorial was created for people like myself who are 1x engineers and the kind that grasps concepts in a few days/weeks, not seconds. If you are a big brain or a 10x engineer, STOP READING, this will be no good for you.

Create and Deploy

To use a Ceramic data model within an application, you will need to either use a standardized model from the Data Model Registry(there are currently only a few available) or deploy the data model to one of the networks(testnet or mainnet) and use the JSON file to link the data models in your application.

Example JSON Aliases

{
  "definitions": {
    "myAddressBook": "kjzl6cwe1jw1487esfmzik6u8hd9swrut7i73a1b7e8m0gqza0xxuhd61l952hs",
    "DIDToAddressBook": "kjzl6cwe1jw145wbun7wd2507nf00thucutl5wgrl5gtbq8mh852ux33z5si6j6"
  },
  "schemas": {
    "AddressBook": "ceramic://k3y52l7qbv1frxxzi0b8ecysa2rlbtrzwt78blhu9grb9ywdnwda918psqxtc7xts",
    "DIDToAddressBook": "ceramic://k3y52l7qbv1frydo84ulca4ps700j88id1roidw6j4vfnpln8mjo63694x0trtji8"
  },
  "tiles": {}
}   

Today, we will learn how to deploy and create a pull request to add your brand spankin new data model to the registry and make sure others can use your incredible work.

Get the Glaze CLI

The team at Ceramic has built an array of great software to help you interact and develop on the platform. Glaze suite is a middleware that will help you interact with data models and nodes.

• Install Glaze CLI

npm install --global @glazed/cli

• Create a local DID to work with

glaze did:create

Make sure you save the output as you will need to use the seed later in the tutorial with the --key flag

Flags

You will need two flags to send most of the commands below:

• --key: Your seed from above

• --ceramic: the URI of the node you want to connect.

You can get a node URI from the Ceramic Discord #community-nodes channel

Create the Data Model

We will use the Address Book data model used in the ETH Shanghai Hackathon. But before we do, lets look at some good tools to help you use these data models

JSON Schema Tools

• Schema converter

• This will make it easier to see the actual structure of a reversed engineer object from your schema

• JSON beautifier

• This will help reduce your schema to a one-liner if you need it

• Tile checker

• *This will allow you to view your deployed schema via the web

Example Schema

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "title": "AddressBook",
  "required": [
    "total_cnt",
    "contacts"
  ],
  "additionalProperties": false,
  "properties": {
    "total_cnt": {
      "type": "integer",
      "description": "The total number of contacts",
      "default": 0
    },
    "contacts": {
      "type": "array",
      "default": [],
      "items": {
        "type": "object",
        "required": [
          "name",
          "wallets"
        ],
        "additionalProperties": false,
        "properties": {
          "name": {
            "type": "string",
            "description": "The contacts name",
            "default": ""
          },
          "wallets": {
            "type": "array",
            "description": "Collection of the contacts wallet addresses and respective networks",
            "default": [],
            "items": {
              "type": "object",
              "default": {},
              "required": [
                "walletAddress",
                "network"
              ],
              "additionalProperties": false,
              "properties": {
                "walletAddress": {
                  "type": "string",
                  "default": ""
                },
                "network": {
                  "type": "string",
                  "default": ""
                }
              }
            }
          },
          "avatar": {
            "type": "string",
            "description": "Optional URI of user avatar",
            "default": ""
          },
          "tags": {
            "type": "array",
            "description": "Optional tags for the contact",
            "items": {
              "type": "string"
            },
            "minItems": 1,
            "uniqueItems": true
          },
          "data": {
            "type": "object",
            "description": "Fields to include optional arbitrary data",
            "properties": {}
          }
        }
      }
    }
  }
}

• Create Data Model

glaze model:create address-book --key=<YOUR SEED> -c=<NODE URI>

• Add Address Book Schema

glaze model:add address-book schema AddressBook “{JSON}” --key=<YOUR SEED> -c=<NODE URI>

If you have any other schemas. You would insert them now. For the hackathon there was one other Schema that was used - DIDToAddressBook

Definitions

You also want to add definitions to this model for any schemas you have created. -

• Definitions are used in the Index of the DID DataStore.

• An Index is a TileDocument matching the IdentityIndex spec from CIP-11, used by the DID DataStore to associate Definition IDs to Record IDs

Example Definition

'{
    "name": "My address book",
    "description": "Address book to keep track of a users        different accounts and contacts",        
    "schema": "ceramic://k3y52l7qbv1frxxzi0b8ecysa2rlbtrzwt78blhu9grb9ywdnwda918psqxtc7xts"
}' 

• Add Definition

glaze model:add address-book definition myAddressBook --key=<YOUR SEED> -c=<NODE URI>

• Publish the Model

glaze model:deploy address-book publishedAddressBook.json --key=<YOUR SEED> -c=<NODE URI>

Where publishedAddressBook.json is the aliases file you will use in your app.

Example publishedAddressBook.json

{
  "definitions": {
    "myAddressBook": "kjzl6cwe1jw1487esfmzik6u8hd9swrut7i73a1b7e8m0gqza0xxuhd61l952hs"
  },
  "schemas": {
    "AddressBook": "ceramic://k3y52l7qbv1frxxzi0b8ecysa2rlbtrzwt78blhu9grb9ywdnwda918psqxtc7xts"
  },
  "tiles": {}
}

Congratulations!!! You have now built and deployed at DataModel to Ceramic. It is ready to be integrated into your application. We will go over how to do that in another post but let’s first see how you can create a PR to add this new shiny DataModel to the Ceramic Data Model Registry.

Add the Data Model to the Ceramic Data Model Registry

You can find the repository here and an example PR here

• Fork the Data Model Registry Repo and clone on your local computer git clone <YOUR NEW REPO>

• Create a new branch git checkout -b add-new-data-model

• Create a new folder in the /models directory with the name of your data model eg /address-book

• Use one of the existing data models as a template, most of the root files will stay the same apart from package.json that will require some minor changes

• Create a /schema directory and in the directory use the schemas that you just used to create your model and create a file in that directory.

• Create a /src directory and add an index.js file. To get the details that you need for the EncodedManagedModel you will need the following command. glaze model:export address-book exportedAddressBook.json

  **Example exportedAddressBook.json

**

{
  "schemas": {
    "kjzl6cwe1jw147layx2v9p53o0i6q4hzjutuvpkkgf39u7xf68m958jdlsdos47": {
      "alias": "AddressBook",
      "commits": [
        {
          "jws": {
            "payload": "AXESIFHH8eYt5V4Sk7gHQnKgYYjKBPZHCCnJR4OuZgoi6jaU",
            "signatures": [
              {
                "signature": "b4EvyuK3NZr97VmT01nsy4QFCMVBw2ck4yhsNBcLLJIf2ssr687seAOT_b0cvYVoSwDaIrdc8NoBul2JHYZuCA",
                "protected": "eyJhbGciOiJFZERTQSIsImtpZCI6ImRpZDprZXk6ejZNa2VpOXJyelF2aVlqcGJhVjFNcDFhVFVibmY0aWpidTNvekpVZnB5VTVQWGg3I3o2TWtlaTlycnpRdmlZanBiYVYxTXAxYVRVYm5mNGlqYnUzb3pKVWZweVU1UFhoNyJ9"
              }
            ],
            "link": "bafyreicry7y6mlpflyjjhoahijzkaymizicpmryifheupa5omyfcf2rwsq"
          },
          "linkedBlock": "omRkYXRhpmR0eXBlZm9iamVjdGV0aXRsZWtBZGRyZXNzQm9va2ckc2NoZW1heCdodHRwOi8vanNvbi1zY2hlbWEub3JnL2RyYWZ0LTA3L3NjaGVtYSNocmVxdWlyZWSCaXRvdGFsX2NudGhjb250YWN0c2pwcm9wZXJ0aWVzomhjb250YWN0c6NkdHlwZWVhcnJheWVpdGVtc6RkdHlwZWZvYmplY3RocmVxdWlyZWSCZG5hbWVnd2FsbGV0c2pwcm9wZXJ0aWVzpWRkYXRho2R0eXBlZm9iamVjdGpwcm9wZXJ0aWVzoGtkZXNjcmlwdGlvbngpRmllbGRzIHRvIGluY2x1ZGUgb3B0aW9uYWwgYXJiaXRyYXJ5IGRhdGFkbmFtZaNkdHlwZWZzdHJpbmdnZGVmYXVsdGBrZGVzY3JpcHRpb25xVGhlIGNvbnRhY3RzIG5hbWVkdGFnc6VkdHlwZWVhcnJheWVpdGVtc6FkdHlwZWZzdHJpbmdobWluSXRlbXMBa2Rlc2NyaXB0aW9ueB1PcHRpb25hbCB0YWdzIGZvciB0aGUgY29udGFjdGt1bmlxdWVJdGVtc/VmYXZhdGFyo2R0eXBlZnN0cmluZ2dkZWZhdWx0YGtkZXNjcmlwdGlvbngbT3B0aW9uYWwgVVJJIG9mIHVzZXIgYXZhdGFyZ3dhbGxldHOkZHR5cGVlYXJyYXllaXRlbXOlZHR5cGVmb2JqZWN0Z2RlZmF1bHSgaHJlcXVpcmVkgm13YWxsZXRBZGRyZXNzZ25ldHdvcmtqcHJvcGVydGllc6JnbmV0d29ya6JkdHlwZWZzdHJpbmdnZGVmYXVsdGBtd2FsbGV0QWRkcmVzc6JkdHlwZWZzdHJpbmdnZGVmYXVsdGB0YWRkaXRpb25hbFByb3BlcnRpZXP0Z2RlZmF1bHSAa2Rlc2NyaXB0aW9ueENDb2xsZWN0aW9uIG9mIHRoZSBjb250YWN0cyB3YWxsZXQgYWRkcmVzc2VzIGFuZCByZXNwZWN0aXZlIG5ldHdvcmtzdGFkZGl0aW9uYWxQcm9wZXJ0aWVz9GdkZWZhdWx0gGl0b3RhbF9jbnSjZHR5cGVnaW50ZWdlcmdkZWZhdWx0AGtkZXNjcmlwdGlvbngcVGhlIHRvdGFsIG51bWJlciBvZiBjb250YWN0c3RhZGRpdGlvbmFsUHJvcGVydGllc/RmaGVhZGVyomZ1bmlxdWVwZjloTjNjY0h3U01jeFoyaGtjb250cm9sbGVyc4F4OGRpZDprZXk6ejZNa2VpOXJyelF2aVlqcGJhVjFNcDFhVFVibmY0aWpidTNvekpVZnB5VTVQWGg3"
        }
      ],
      "dependencies": {},
      "version": "k3y52l7qbv1frxxzi0b8ecysa2rlbtrzwt78blhu9grb9ywdnwda918psqxtc7xts"
    }
  },
  "definitions": {
    "kjzl6cwe1jw1487esfmzik6u8hd9swrut7i73a1b7e8m0gqza0xxuhd61l952hs": {
      "alias": "myAddressBook",
      "commits": [
        {
          "jws": {
            "payload": "AXESIFEWkK7SHlFy3aQWYiDEEhXgV561SEgurYkeaqNnGz7n",
            "signatures": [
              {
                "signature": "CYXT973re2KrezmZhr3KLzHdu9ZjBBXFonKwp1C3VhbL7pJz4wWYD64yY1NMLv1nYWJ-Dp3pkvKjxvf__zMXCw",
                "protected": "eyJhbGciOiJFZERTQSIsImtpZCI6ImRpZDprZXk6ejZNa2VpOXJyelF2aVlqcGJhVjFNcDFhVFVibmY0aWpidTNvekpVZnB5VTVQWGg3I3o2TWtlaTlycnpRdmlZanBiYVYxTXAxYVRVYm5mNGlqYnUzb3pKVWZweVU1UFhoNyJ9"
              }
            ],
            "link": "bafyreicrc2ik5uq6kfzn3jawmiqmieqv4blz5nkijaxk3ci6nkrwogz644"
          },
          "linkedBlock": "omRkYXRho2RuYW1lb015IGFkZHJlc3MgYm9va2ZzY2hlbWF4S2NlcmFtaWM6Ly9rM3k1Mmw3cWJ2MWZyeHh6aTBiOGVjeXNhMnJsYnRyend0NzhibGh1OWdyYjl5d2Rud2RhOTE4cHNxeHRjN3h0c2tkZXNjcmlwdGlvbnhFQWRkcmVzcyBib29rIHRvIGtlZXAgdHJhY2sgb2YgYSB1c2VycyBkaWZmZXJlbnQgYWNjb3VudHMgYW5kIGNvbnRhY3RzZmhlYWRlcqNmc2NoZW1heEtjZXJhbWljOi8vazN5NTJsN3FidjFmcnkxZnA0czBud2RhcmgwdmFodXNhcnBwb3NnZXZ5MHBlbWl5a3ltZDJvcmQ2c3d0aGFyY3dmdW5pcXVlcFFEMTVXWE5PT2ZJMkhlNlRrY29udHJvbGxlcnOBeDhkaWQ6a2V5Ono2TWtlaTlycnpRdmlZanBiYVYxTXAxYVRVYm5mNGlqYnUzb3pKVWZweVU1UFhoNw=="
        }
      ],
      "schema": "kjzl6cwe1jw147layx2v9p53o0i6q4hzjutuvpkkgf39u7xf68m958jdlsdos47",
      "version": "k3y52l7qbv1fry2cp677gjzkn0bidpl233pdefbdbol98jb3uvapcorhmzb501qf4"
    }
  },
  "tiles": {}
}

• Create Types from your Schema yarn types

• Check that the package builds yarn prepare

• Test that it can be published yarn prepublishOnly

• Commit changes git add . git commit -m ‘Add new data.model’

• Push to the remote repo git push

• When you now go to your repo in Github, you will be able to send a pull request with your changes to the Ceramic DataModel registry repo.

  NICE!!! You have now contributed to Web3 and the open-source community built around the Ceramic protocol.

If you have any suggestions on making this tutorial better, opinions or want to chat. Feel free to reach out via Twitter or Discord

Enter Aptos

Many of the engineers that help build the codebase did not just want to leave the work that was done and after Meta announced it would no longer be going ahead with the project, the builders decided to build their own network. In their words:

A Layer 1 for everyone - Building the safest and most scalable Layer 1 blockchain.

The ecosystem is growing fast with multiple projects building using the Diem/Move codebase. This includes:

• 0L(Open Libra) - A unique economic experiment not backed by VC’s and instead built by a community of dedicated individuals.

• Mysten Labs - Other previous Meta employees who have built Sui and are bringing Move, along with Technologies like Narwhal and Tusk to projects like Celo and Sommelier

• Pontem - The Experimentation Platform for Diem Blockchain Technology built around the Polkadot network

Introduction

This article intends to show how easy it is to build a client-facing React project using the Aptos API. This is by no means an end product and development is happening daily that will likely make this obsolete very quickly. If this helps at least a few people get exposed to this new ecosystem and project it served its purpose. Subsequent articles will follow the journey and dive deeper into writing and using the Move language to build applications.

Repo: Aptos Faucet

Creating the React App

npx create-react-app aptos-faucet --template typescript

Folder Structure

my-app/
  README.md
  node_modules/
  package.json
  public/
    index.html
    favicon.ico
  src/
    App.css
    App.js
    App.test.js
    index.css
    index.js
    logo.svg

This will build a base React App we can work with. There are essentially minimal changes that need to be made so we will break them up into three categories:

• UI changes

• UI logic

• Connecting to the Aptos API and handling the connections in the client

UI Changes

Most of these changes can be done in the App.tsx file in the projects /src folder

Before

import React from 'react';
import logo from './logo.svg';
import './App.css';

function App() {
  return (
    <div className="App">
      <header className="App-header">
        <img src={logo} className="App-logo" alt="logo" />
        <p>
          Edit <code>src/App.tsx</code> and save to reload.
        </p>
        <a
          className="App-link"
          href="https://reactjs.org"
          target="_blank"
          rel="noopener noreferrer"
        >
          Learn React
        </a>
      </header>
    </div>
  );
}

export default App;

1. Change the logo to a nice faucet design and remove css

   1. Change logo.jpg file in /src

   2. Remove CSS - here and here

2. Import modules for UI and Aptos logo

   1. Import Modules

   2. Add a new aptos_logo.png in /src

3. Add additional UI code

4. Adjust CSS

UI Logic

We then need to make sure the appropriate logic is in place to handle the buttons and modals associated with the UI changes.

1. Add UI state

2. Add Modal functions

3. Add Warning functions

Connecting to the Aptos API

The code and examples mostly come from the Aptos tutorials.

1. Add an accounts.ts file in a new /src/ts folder to use to interact with the Aptos API

2. Connect this with the UI

   1. Import the accounts.ts functions

   2. Add the Aptos endpoints

   3. Create Account function

   4. Add Funds function

3. Add wallet state

Using Your New Faucet Application

Create a New Account

You can create a new account by clicking the ‘CREATE ACCOUNT’ button. This will provide you with an address, public key, auth key and private key.

Note: The account will not be stored on the Aptos blockchain untill it recieves funds and interacts with it.

Fund your new Account

You can now fund this new Account by clicking ‘FUND ACCOUNT’. The last created account will be used by default but you can change it to your address of choice if needed. Enter the amount and click ‘GET FUNDS’. Voila you now have an account on the Aptos Devnet.

Hopefully this gives you the push you need to get involved at dive deeper. You can follow my journey as I post about my journey becoming a psuedononymous developer on Mirror or Twitter.