Jobs of the Future: AI Prompt Engineer

[city landscape], on neutral background, … , ultra wide lens — Dall-e

Come with me and you’ll see a world of pure imagination — Willy Wonka


In the near future you will be looking to hire a new type of thought worker(or potentially see this skill as often as ‘proficient at excel’ on resumes). This up and coming talent is known as “prompt engineering” and it is time everyone started the discussion and using this amazing new tool.

tiny cute green plush stuffed toy, anthropomorphic, surrounded by vines, pixar style eyes, pokemon anime style, octane render, fantasy, volumetric light, soft cinematic lighting, tinycore, cutecore, purplecore, realisitic, 8k — StableDiffusion

Huh, Say what?

Prompt engineering/hacking/designing is the practice of crafting Text-to-Image prompts in a way that to create consistent, useable, high quality images for others to use. Text-to-Image is the latest generation of AI which lets users provide a “prompt” similar to a search engine. Unlike a search engine, the images created are completely generated from the engines models “imagination”. The more accurate the prompt, the quicker and more accurate the results are. To be clear, the AI is not searching a database of images to find the closest matches; everything is generated from latent space, in real time. From your mind, to the prompt, to a never before seen creation. You are not constrained by physics, reality, your artistic ability, software licenses, etc, etc, etc. Think it and it comes into existence. Prompt engineering is the art of tuning the words, weights, and perspective into what a customer actually wanted. This technology is not limited to 2d images and is rapidly evolving to AR/VR and everything in between.

“How could a business possible use this?”

Lets talk clip art. There is an unusually large market on the internet for art that can be used in presentations. Businesses pay large amounts for clean professional images that capture the idea they are trying to convey. If I want a clipart coffee cup, a quick google search brings up their best options with various licensing fees and usage rights. Using prompt engineering skills we can generate a basic(ugly) object with relative ease:

flat art coffee cup

This prompt created a useable, image that at least gives the general IDEA of a flat art coffee cup. With a little prompt engineering magic we can produce a much better image:

Engineered Prompt

And since this is a computer program running in the background we can add some spice to the prompt to make it capable of generating many more items in the same style.

A [configurable] Prompt for sale

Building A Metaverse Business Model

Having a prompt one person can use is good. I want more.

So, how can others benefit from (or pay me for) my newly found creative skills? There is a service called “prompt base” which is an emerging market place for prompts. Since we are hoping to push the frontier, this article calls for a bit more…. pizzazz 😁.

I’ll spare the exact details in this post, however, I created an ERC-1155 NFT token on OpenSea which will allow me to create unique assets with unlockable content. Instead of a picture of a monkey, I will allow up to 500 users to purchase the NFT and the owners can reveal the prompt without me ever having to be involved. When a customer buys my prompts they are not buying 1 unique image, they are buying the ability to generate endless variations of my prompt’s styled objects with anything they want(🤯). Bought it for office art, use it to make cars or sunglasses. If they decide to resell their access, I will get 2% of any future trades. At the time of writing this I am offering these custom prompts for ~$1.50 worth of crypto coin. These are also carbon neutral NFTs, the code sits on Polygon network(a L2 for ETH) and the transfer fees are almost non-existent.

Lets do more…. As a prompt engineer I need to drive traffic to my new store, so customers can sample the quality of the products first hand. I have seen others using for their NFT collections and I think this is the perfect opportunity to set up my shop and let the world know we’re open for business. Spatial is a virtual world platform where users can interact with each other, share experiences, showcase art & NFTs.

From zero to a metaverse business in a few hours worth of time. No coding, the future is amazing. Check out The Collection here!

Grand Opening

Dive in 🏊‍♀!

Ready to start the journey down the rabbit hole? The engines are available to the public and most are free to use with a paid model once you get hooked


Market place:


The 3 really important things you need to know about IPFS right now

Think of the internet 20 years from today. Tens of billions of people, trillions of IoT gadgets, millions of data centers; all using currently unimaginable connected devices, all wanting to access data from around the world instantly. What do you think that will mean for the system holding all of this together in the background, the humble file transfer protocol used to move all data around?

Enter the Interplanetary File System(IPFS for short)! A fundamentally different network designed around creating a more secure, open, and flexible system. Learning about and using IPFS today is important because now is the time to be placing your bet on how the internet evolves from here. Fortunately understanding the 3 really important things you need to know will be a piece of cake 🍰

#1: It is NOT a Blockchain⛓️

Blockchain is hot these days, and everyone wants a piece of it. If you’re here to learn how a new one works you will be greatly disappointed with this article because first and foremost: IPFS IS A FILE SYSTEM.

Blockchains are a form of distributed database where all the nodes share the exact same information set (very_broad_brush.jpg). These are very useful for a very specific set of problems. Cryptocurrencies, supply chains, and digital identity are examples of use cases being built on them today. If a large group of people want to make sure everyone has the exact same unforgeable data, they can use a blockchain. If everyone on earth wanted to share the ultimate cake recipe and ensure everyone had the exact same version, they could use a blockchain. 👩‍🍳

File systems are much, much more useful. You likely send and receive files everyday and equally likely never give too much thought of how they are stored, addressed, our distributed. And one thing everyone can be certain of is that they do not have all of the files that exist(nor should they try). In fact, the entire internet was invented to figure out how to arrange and find information when you don’t have all the files you need.

If a blockchain is a recipe(🧾) that everyone shared, files can be thought of as the individual ingredients(🛍️) you have/need. IPFS(🛒) is then a very efficient way to get the ingredients to you kitchen. 🧾 + 🛍️ + 🛒 = 🍰

#2: It’s about the Content🛍️, not Location🗺️

The traditional internet is location based. You tell a web browser where to find a website and it goes to the server and asks for the information. IPFS turns this concept on its head. With IPFS, you tell the network which file you want and it asks the network of peers who has it.

This concept isn’t as strange as it sounds. Recall the last time you were looking for an ingredient you needed to make a cake. You called ahead to the store so you can do curbside & have two options of hopefully finding it; you can either ask the sales associate to get some flour for you (this is content addressing because you’re asking for what the ingredient is) or ask them for the ingredient on isle 4, 3rd shelf, 15th item from the right (the last location where you knew your ingredient was, location addressing)

Since we don’t care where the flour comes from, only that it is the exact ingredient we need, this is a much more efficient way of ordering and receiving – and content addressing is up to 60% more efficient for online videos as well.

#3: It can Literally Save the Internet 🌐

The internet of today has a huge problem that tech folk don’t like to talk about. Our collective demand for streaming content is literally crushing the decades old infrastructure that hosts and delivers our favorite content to our homes and devices.

The hard truth is that “the cloud” is just some mega corporation’s data center and it is limited by same physics as everything else in the universe. A finite amount of data can go in and out at one time.

If you have ever seen the result of a video or website ‘go viral’ and kill a small hosting service you have seen this experiment conducted before. IoT and entire digital native generations are coming to hog all the bandwidth, and they are closing in fast.

The Interplanetary File System will allow the next generations of our beloved infotainment services (ie Netflix, Hulu, and YouTube) spread out the load across a decentralized mesh with absolute guarantee that the data you are getting is exactly what you wanted and unaltered.

For our cake🍰; instead of everyone going to the to same store to get flour (causing shortages and poor social distancing) in the future everyone will just ask their neighbors for flour!


What do you think ? Do you want the world to be powered by distributed networks like IPFS or not ? What about your business? What do you think about the risks of this paradigm shift ? Let us know your thoughts in the comments below!

A real deep dive on the tech:
The paper that gave birth to the internet:
60% faster videos:

Level up your online meetings

I have dreamt of apocalypse many times, but never did I imagine one during which I would have to have a day job and attend endless online meetings.

Since the lockdowns, video calls have become my day to day life. They consume countless hours a week and are the primary use of my computer now. The tools of the trade I use most are Powerpoint and Teams, but the steps that follow can be modified to the limits to your imagination.This setup could be useful to students, podcasts, streamers, and anyone who uses a computer and wants to do less. The first rule of apocalypse is to have fun and be yourself. 🙂

The Plan

The goal of this project is simple: Create a macro keyboard for the things I use the most without breaking the bank.

Like many who have ended up on this blog; I am a gamer, a technologist, and like shortcut keys. I am always looking for a way to blend these things together.

I’m a classic gamer with a preference for 8-bit NES. As such, I already have a USB controller(which everyone should) so this is what I would prefer to use in my day to day gig. If you want more buttons you can go for a different controller, but your loss in the gaming aspect.

For project budget and costs, this is the only item needed. An NES gamepad costs ~$12 for a 2 pack and are available at all the finest online retailers.


Next, with the hardware settled, we need to decide what matters most in day to day use and can be mapped over 8 keys

For me it is these:

  • Mute/unmute
  • Video on/off
  • Join a meeting
  • Admit to the lobby
  • Volume up and down
  • Scroll slide decks

The actual layout will be something like this:

Well this is what it looks like

I would have liked a “hand raise and lower hand” key but there isn’t a hotkey I could find so, if you work on this product I really need this.


Obviously everything on the software side needs to be open source so no funny business is going on under the hood. I found antimicro and it fits the bill. Though it is currently unmaintained, it is functional and works well enough for my needs. You can find the releases and source code in their github:

The Execution

Putting it all together took about 30 minutes, counting troubleshooting and blogging.

First things first; plug in controller and install the software

Plug in the USB controller and you are done

There are some parts which are less intuitive and I will cover them to close out this article, but this the sky is the limit once you figure out shortcut keys you need for an application.

To get the shortcut keys in Teams, press `Ctrl + <period>` and you will get a menu similar to this:

Teams Shortcut keys screen grab

Now press buttons on the controller to see which button it is associated within antimicro. It is very intuitive

For volume keys (up and down on D pad), you can select the option from the “others “ dropdown on the key assigner.

Location of the volume keys during setup

For the complex key combinations, use the advanced mapper on the bottom left of the keypad to sequence your keys.

Macros in Micro

Having now successfully customized your rig, you are now one of the coolest console cowboys at the end of the world. Good luck!

End of Active Service with Ethereum Classic


Firstly, I have thoroughly enjoyed the 4+ years of being a part of the ETC community, seeing it grow, take form, and riding the roller-coaster with my internet friends and acquaintances. We were pioneers and have unquestionably left a positive mark on the blockchain industry and open source software. My time we here has given me rare insights into decentralization and leaderless organizations and an amazing opportunity to develop next generation technology with brilliant like minded people.

Why I’m Leaving

As many of you know, ETC has always been a volunteer/passion project for me. My pursuits here have to be balanced with my other obligations in life. This pattern was easier to maintain in pre-covid times and when the project was in incubation. I want to enjoy the last few years of my children’s childhood. My wife, and love of my life Jen, has always supported me in this pursuit also, but my time at ETC has always come at the expense of some family time. The calculus on the value of those hours has changed in the last year. I no longer want to be tethered to my phone arguing with strangers online during diner and homework time. And I want more freedom to have time to explore new and exciting technology as well.

The Road Ahead

Unquestionably, ETC and I are both in better places than when we started. The network and its participants are coming to a fork in the road. The treasury conversation we’ve had off and on for 4 years may be coming to a resolution in the next few months. if not obvious until this point, I will not be participating and will try hard to refrain from any further intervention either way. ETC has always been a managed chain like all public projects with shared goals. That is what a community does and how highly specialized technology is maintained. The conversation now is whether it is to be semi-autonomous or supported with a superfan helping it grow. Both are very valid models that are in keeping with the history and spirit of ETC. I am neutral now and look forward to seeing the peaceful split of communities or emergent governance that develops.

Selling assets

I think there are several possibilities of future states for ETC. I have privately informed Terry(etc labs), Charles(iog), and Bob(Coop) last week I will be selling the rights to the domains I have in my possession to whichever is the highest bidder by November 30th. If none of them can find a way to value it, the domains will go to public auction. This bidding is not any indication of someone buying the chain ETC itself or a corporate takeover, though it will likely be framed as such by the non-winners. The community should make their voice heard on this as well. All three love ETC and have valid roadmaps and development plans. I don’t want the burden of having to be king maker if a chain-split is the best path for growth.Especially as I plan to disengage from actively participating. Managing a domain or repo has been an honor and the community will be fortunate with any outcome.


As i spin down, I will be making this hopefully as seamless as possible.

-I will keep kotti validator running until a replacement operator can be transitioned in properly.

– I am happy to remain in a non paid advisory position on boards until a their natural resolution.

– I will continue administrative duties on the github repo until the community finds a replacement.

– I will retain my community wallet keys and gladly use them to unlock funds when needed


I am forever grateful for the people I have met, the debates we have had, the amazing community that exists, and the memories I’ll always have. I look forward to cheering from the sidelines as ETC embarks on its next exciting phase of the amazing journey. But for me, this is where Peter Pan must leave Neverland.

Semper Fi,

Cody (DontPanic) Burns

On Recent Event in the Ethereum Classic

There is a new startup in the Ethereum Classic space that has caused a bit of a stir with their initial actions and I would like to take a few minutes to comment on them. For brevity, there is no distinction made between etclabs, the “startup incubator” and DFG, the desperate speculator group. Some may remember them as they made presentations at the ETC summit and they have held themselves out to be a new development team in the space and hopefully they can recover from their recent missteps and join the other dev teams working in the space. Since they are struggling and need some air time, I am writing this open letter to ease the on boarding process.

Not like this

How Git Hub Works

For clarity sake, github is the system many open source projects use for coordination and version control. It is one of about 5 systems in the CI/CD pipeline that are used to ensure distribution ETC related software. Individual repositories(repos) contain projects, and they are consolidated into organizations (orgs) for easy of search and moderation. There are two roles that are part of a github org, member and owner. “Owners” have the ability to add members, add/del new repos, and change members status (even removing other admins status), and more importantly add CI/CDapps and web integrations, You broke all of those because you are incompetent, please ask if you don’t know what you are doing. There are infact, and have always been, several ”ETC” orgs. IOHK, Parity Tech, BCRD, ETCDEV, etc. In the past, they work on code in their parent org and then merge it with the main branch in the ethereum project org for easy of coordination. Owners do not “own” open source orgs(google: foss), members do. Members are allowed to submit and merge code. Should the new dev group, ETCLABS, have been made members, absolutely! In fact anyone who wants to contribute can and should be made a member. After they foolishly removed all admins from the ethereumproject repo and lost control of the krykoder account, I added them as members to the back up organization ethereumclassic. I have transferred all of the projects I had created to the new repo and the chain moves on. Currently there are 4 “owners, and I will direct you to the volunteer page to see the new requirements that no admin can remove other admins without consent of all to prevent accidents like what had happened to the last org. We are more than happy to add more “owners” if the need arises. But you will need to actually produce work and be active in the community, money doesn’t matter.

ECIP process
ETCLABS has express concerns about not having a voice in the process of improving ETC. The first resource they should use is . It will answer many of your noob question regarding testnets, wallets, dapps, etc. If your only concern is about price, I canât help you there other than saying ethereum systems work better when the price is closer to zero than 1 million, but as a speculator group you should have looked into that before losing everyone’s money. For anything else that can improve the ecosystem or network, you need to follow the Ethereum Classic improvement proposal process. This is the common way to make suggestions, you don’t need to strong arm a development team or even ask permission. The repo is located at now that the ethereumproject repo has been deprecated. You may be interested to know that another development group with actual chops has proposed a universal set of status codes, I had proposed op code compatibility changes(which should be coming sometime after the Constantinople fork opcodes are tested in January), and several other exciting things that maybe etclabs can even try to help with.

In conclusion

Welcome to Ethereum Classic ETCLABS! I look forward to the day you actually produce anything other than bizarre press releases. Also, please try to refrain from using my name in your revisionist history unless it accurately reflects my contributions to your work. Aside from once conference call with the other development teams, in which you profusely apologized for screwing up the git org, I have never been in contact with you. Feel free to ping me on literally any social media channel as dontpanicburns or email me if you need anything.

An Introduction to Stateful Blockchains

Modern blockchain technology relies on different principals than previous generations of blockchains, known as UTXO or generation 1.0, and allows for more robust transaction execution. An introductory stateful blockchain can be expressed as a game of correspondence chess.

The rules of chess are understood by all participants in the network and, as such, it is understood that a knight has a certain series of functions, or moves, it is able to perform. The same holds true for the other pieces of the game.

Genesis state

The genesis state of a traditional the game is presented in figure A. Both participants have a series of pieces that they are able to use and have agreed on the current positions of each. This is conceptually similar to smart contracts on a blockchain. Each contract has a predefined set of functions that are controlled by rules just as each piece as a predefined set of moves it is allowed to make in game play.


In the correspondence chessboard network our consensus mechanism is set as such: each member must make 1 legal move per block. Once the player decides on the move, it must be submitted to a judge. Unlike modern blockchains, the chess game also requires each participant make their move in proper order. The dark pieces are forbidden from sending a transaction until the light pieces have made their commitment. When the light side player submits their move to the judge, it is visible to everyone and unable to be changed. Once both sides have made their commitment to a move, the block is captured as a list of moves (state changes) in PGN format and numbered from the genesis state.

The blockchain and the state

An example of a possible valid block number 1 could be: 1 d4 ♞f6. The

“blocks” are just a list of the moves that were made, not the actual pieces. This can be translated as the light side moving the pawn from d2 to d4 and the dark side moving their knight from g8 to f6. Both are valid moves and arrived in the correct order, so per our consensus rules this is a valid block. Each player will update their board with the new ‘state’. Players are only concerned with the current state, which contracts they can interact with, and what move they want to make next.

Syncing and Validating

As the game progresses, it is possible for any outside participant to validate the current state by reading through a the PGN list of moves from genesis and recreating the game. In the blockchain space this is known as syncing a node. If one of the players needs to take a break or knocks over their board, they are able to sync their board to the current state by reading the move list. A faster way of syncing would be to take a snapshot of the current state and send it to the validator along with the PGN. They would then have the current state and can validate it as needed. This allows for seemingly complex chess games to be replayed and studied by a broad audience.

State size and the evm

In a stateful blockchain system such as Ethereum, all of the rules from above still apply. Each node keeps a copy of the blockchain so they are able to validate their current copy of the state and the state began at a commonly agreed upon genesis block. By viewing the state, a participant is able to see contracts on the system in the same way they would see all the chess pieces at any state in the chess game. Similar to each chess piece, each smart contract has a series of rules and permissions associated with it. that govern its behavior. In contrast to the chess game, participants in the ethereum network are able to add valid contracts at any time in the form of a transaction. They will send the transaction to a node responsible for creating valid blocks. Once a series of transactions have been validated, the block of transactions is sent to all the participants who then update their local state. Participants only care about the current state, which contracts they can interact with, and which transaction they want to make next. As the state is shared between all participants, it is important to minimize the amount of data stored on leaf nodes of the states Merkle tree

image from ‘Merkling in Ethereum’

In an ethereum system, all accounts follow the same formatting scheme and are mapped by their unique account address. Both user accounts and contract accounts are stored in the same manner. Each account has:

  • The nonce, a counter used to make sure each transaction can only be processed once
  • The account’s current ether balance
  • The account’s contract code, if present
  • The account’s storage (empty by default)

Each node stores a list of all accounts that have ever made a transaction on the system and maintains the Merkel root of all accounts. When a transition arrives in a block, the new state root is computed and validated against the blocks state root.

For more info on ether trees check out:

How to Make a “T” to “Z” Transfer in Zcash

Informal twitter poll of zcash knowledge

The Zcash value proposition is in private transactions, however, private transactions are not the default and many users simply do not know how to initially create shielded (private) transactions, aka a “t” => “z”. In simple terms, it is important to have a large pool of shielded transactions provides for a larger anonymity set for private transactions; it is harder to pick out any one zebra in a large zeal than it is to point out a single animal in a small cluster. This process, and having more people familiar with it, provides greater value to my work on cross chain atomic swaps (x-cats in zcash speak) so I have attempted to unravel the apparent mystery below. No math, dark magic, animal sacrifice required.

Side note: If you would like to contribute to the greatest good, while exerting minimum effort for the zcash ecosystem, hold you coins in a “z” address. this benefits everyone using zk transactions and increases the size of the anonymity set. Currently, as shown below, this is an uncommon practice.



The general process for shielding ZEC is as follows:

  1. Generate both a “t” address and “z” address

The “t” address works the same as a bitcoin address. When you send from your transparent address the change from the transaction will be sent to a new t address you control and all the transactions will be visible on block explorers. “Z” addresses are the private ones and you will only be able to see the balance in the wallet. When sending to and from a Z address, only the exact amount (minus fees) is sent, the change remains with the same “z” address. No one observing the transaction will see any information about the “z” address, except during shielding and deshielding.

2) Fund the “t” address

Funding your “t” address means sending ZEC to it. Zcash can be traded for or purchased many places. Gemini allows US customers to purchase ZEC with US Dollars.

3) Send from your “t” => “z” using a zcash wallet such as zcashd or winzec

It is actually as easy as that sounds. Sending from “t” to “z” or “z” to “z” or “z” to “t” is all the same procedure. This step is overlooked in the zcash documentation because it is so trivial. Maybe they will add it in future versions to avoid confusion.


“t” addresses send change to new accounts, “z” notes do not

do not send from “z” => same “t” or the change account, always use a ‘clean’ “t” address when deshielding

avoid sending the same amount into and out of shielding transactions. While 10 zec in and out is less traceable than 2.3123 zec, 10 zec in and a random amount of zec out is better



0. Get zcashd running

Get the latest copy of zcashd ( or use a docker container (docker pull bcrd/zcash)

  1. Generate “t” and “z” addresses

To generate a t address you use the commands

$ ./src/zcash-cli getnewaddress

To generate a z address use the command:

$ ./src/zcash-cli z_getnewaddress

2 . Fund your t address

Send ZEC to the t address created above

3. Send many

If you are like me, you hate typing or even pasting long inscrutable numbers. In linux you can save strings with shortcuts like this:


But actually type or paste your address. after that you can recall it by typing the letters with a dollar sign in front of it:


So assuming you funded your t address with 1.001 zec the `z_sendmany` command will allow you to shield that value:

$ ./src/zcash-cli z_sendmany "$TADDR" "[{\"amount\": 1.0, \"address\": \"$ZADDR\"}]"

Be mindful of the quotes and backslashes, they matter.

This will return you an opid code which is used in your wallet for tracking the shielding process. You can check the progress using:

$ ./src/zcash-cli z_getoperationresult

Status success is what you are wanting. After you get a success you can verify the funds using:

$ ./src/zcash-cli z_listreceivedbyaddress "$ZADDR"

Easy Mode

0. Get winZec

Download the “unofficial” windows version of zcash. It can be found at

1. Create addresses

click the new T (transparent) address button

click the new Z (private) address button

2. Fund

Fund your “t” address

3. Send


On the send cash tab, select your funded t address. enter your z address in the destination address and the amount to shield.

Click send and watch the progress bar to see when it completes

That’s it!

Note: When you are sending, there are two fee boxes. The first is the network fee, you must pay this to have your transaction included in a block. The second is the wallet dev fee, this is an optional donation to ralfstx to support the windows and mac wallet development. If you have used both methods, you will quickly realize the importance of gui and its continued funding. Open source development is often a thankless process, so money is always nice way of saying thank you.



Continuity for an Augmented world

Let’s preface this article with a bit of hand waving. Please assume that we live in a world 5 minutes into the future where we have figured out AR implants or non-ridiculous glasses. However, for now your mobile exo-brain(phone) will work.

I will begin by saying I have felt robbed for some time now. Something is missing. I was promised the future would be a late-stage capitalism state where I would be inundated with interactive 3d advertisements in a gloomy Phillip K. Dick urban sprawl. Granted we are close. I build and trade imaginary internet coins, work for a multinational tech conglomerate, carry a super computer in my pocket, and have a handful of nonhumans living in my house. But I know we can do better. Also <*handwaving intensifies*> in a more decentralized way! Free market persistent advertisements should be everywhere now. Since no one seems interested in making this a reality, I guess I will have to step my game up. Be the change.

On of the most common pitfalls of modern AR is the lack of continuity with actual reality and even itself. I believe this disconnect can be remedied with modern public blockchains. In order for the system to be robust enough for wide spread usage, it will need distributed file storage for rapid access of the advertisements, a public market for advertising space, and a simple recognizable target for the advertisement(to project on, obviously YOU are the real target). And it also goes without saying this will all need to be open source. With these requirements in mind: lets do this!

Burns Capital: Research and Development

For this proof of concept we will be using a the Burns Capital . The success criteria will be if you, the reader, are able to see this logo on demand anywhere in the world. I am using a simple image for demo, however it is just as easy to make 3d objects and any other objects using the same method. That will hopefully be covered in another article. Also, This is living code so it will be updated likely by the time you are reading this. The repo link is at the bottom, its open source, help yourself to the latest code base.

If your impatient; on your mobile, go here

and point your phone at this:

Ethereum Classic ad on the network

System overview

System overview

Before we get too deep into the coding aspect of the system lets briefly look at the network design. 1) A user is served a lightweight web application from ipfs, 2)the webpage uses a public api to access a 3) contract on the ETC network to get information about targets and 4) the advertisements are then retrieved from ipfs and 5) displayed at the target. I refer to this as zero weight architecture.

Dive deep!

File storage:

This one is the easiest of the four requirements. If you are unfamiliar with the interplanetary file system (IPFS), stop everything you are working on, learn about it, and start using it now. When a file is added to the ipfs, it is given a unique identifier. This identifier is used to distribute the file to other ipfs nodes and recall it as needed. Super useful in our case.

$ ./ipfs.exe add ~/Pictures/bclogo.png
added QmRYrsq4uHk3AuVapdyoPtbF4zuzw7dbkc4r8HBKssB3De bclogo.png

The BC logo is now available EVERYWHERE!!!!!! Not super impressive, the internet has existed for some time now but we can now access our unique image using an ipfs API point on our machine or any other machine attached to the ipfs system using its id. The file is also publicly available at the ipfs api point is located at:

Distributed access

Constantly passing around QmRYrsq…. is painful and scales poorly. Being a blockchain architect by trade, this is obviously the job for my baby: Ethereum Classic! We will need a contract which we are able to write to once, and read many times. It would also be nice if no one could over write my logo with out my permission. Other nice to have features include: public rating system like movies and games have, the ability to resell my ad space, and a one to one mapping. To do this we will create a structure and an enum.

enum ratings{G,PG,PG13,R,NC17}
struct arTarget {
string logo;
bool owned;

address owner;

bool forSale;

uint price;

ratings rating;


For simplicity in this demo, we will only be using uint8. This gives us 255 unique seats to map advertisements to which should be plenty to demonstrate the concept.

mapping (uint8 => arTarget) public targets;

A bit on targets

We will be using a 3×3 matrix format without error detection or correction, allowing up to 64 different markers to be identified. They 3×3 targets can be downloaded from this link for your convenience. Yes we are only using 64 of the 255 available seats. In a real future world production environment we can easily scale this up to many many more seats and use a slightly larger grid. The idea is to avoid overly complex structures like qr codes and keep it human readable and if need be drawable.

Reading data from a target

We will need a simple getter to allow users to access the stored information. The two most important pieces of information we will need are the image identifier and the content rating. Some sort of nanny monitoring software should be able to read the content rating and block sensitive viewers from seeing age inappropriate items if desired(out of scope).

function getLogo(uint8 _scan) public view returns(string ipfs, ratings rating){
ipfs = targets[_scan].logo;
rating = targets[_scan].rating;
return (ipfs, rating);}

Buying(and selling) a Seat

This is where things get a little tricky. We need a way for owners to update their seats, new users to buy seats, and both to buy and sell.

function updateLogo(uint8 _arID, string _ipfs) payable public returns(bool success){}

We will take an ID and a string with the unique identifier. This function is payable so we can allow users to buy seats. If everything goes well, we will return a successful result.

The easiest case, a seat is not owned and someone wants to occupy it; we let them. That would look like this:

targets[_arID].logo = _ipfs;
targets[_arID].owned = true;
success = true;}

To save space we will combine the actions that an owner can do and what a stranger can do to an unowned asset. Just pass everything you need to claim a seat

if(targets[_arID].owned && msg.sender == targets[_arID].owner || !targets[_arID].owned){
targets[_arID].logo = _ipfs;
targets[_arID].forSale = _forSale;
targets[_arID].price = _price;
success = true;}

If a seat is for sale and a stranger sends enough ether to buy the seat, we will pay the owner and change the seat info.

if(targets[_arID].owned && msg.sender != targets[_arID].owner && targets[_arID].forSale && msg.value >= targets[_arID].price){
targets[_arID].owner = msg.sender;
targets[_arID].logo = _ipfs;
targets[_arID].forSale = _forSale;
targets[_arID].price = _price;
success = true;

Simple enough for this use 😊

The Police!

As I have no desire to host a distributed crush film repository or any other hyper-objectionable content we will also add a rating review board and give them the ability to remove content. They are free to make their own system if they like, but I won’t be complicit in supporting it. So to accomplish this we will map the account address of our police union to a boolean variable(true for police, false for non police) and create a modifier we can add to some function that only the content police should be able to do. And in the spirit of transparency, we will publish an event whenever the pigs take something down. It will report the action(“removed item”), which public servant removed the content, and a comment string if we want to capture a reason.

mapping(address => bool) contentPolice;
modifier onlyContentPolice(){
event squeal(string action, address officer, string comment);

To give our thought police something to do we will give them this function:

function clearSeat(uint8 _seat, string _comment) public onlyContentPolice returns(bool success){
targets[_seat].owned = false;
targets[_seat].logo = “”;
emit squeal(“removed”, msg.sender, _comment);
return true;

Now we have a short public storage database contract for our advertisements!

Compile and deploy using your favorite blockchain interface and were ready to go!

The AR part!

Welcome to the world of tomorrow! and AR.js will be doing all the heavy lifting for us. These opensource projects are working to bring vr/ar to the masses by building out the webVR frame work. For a quick intro on making an AR project with 10 lines of code check out:

<disclaimer: I’m not a frontend developer>

We will be adding web3.js to the ar demo so we can interact with our blockchain. To do that we need to add the following to the html:

<script type=”text/javascript” src=”"></script>
console.log(“ o Establishing WEB3”)
var uri = ‘http://localhost:8545';
var web3 = new Web3(new Web3.providers.HttpProvider(uri));

Of course; changing the uri to your preferred api point. For the demo page I will be using the etc commonwealth public api point. Add the contract logic :

console.log(“ o Setting up contract”)

var contractAddress = “0x9868a675D36E2554F559771539F00Ed188A33e69”;
var abiArray =[{"constant":false,"inputs":[{"name":"_seat","type":"uint8"},{"name":"_comment","type":"string"}],"name":"clearSeat","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_arID","type":"uint8"},{"name":"_ipfs","type":"string"},{"name":"_forSale","type":"bool"},{"name":"_price","type":"uint256"},{"name":"_rating","type":"uint8"}],"name":"updateLogo","outputs":[{"name":"success","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[{"name":"_scan","type":"uint8"}],"name":"getLogo","outputs":[{"name":"ipfs","type":"string"},{"name":"rating","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint8"}],"name":"targets","outputs":[{"name":"logo","type":"string"},{"name":"owned","type":"bool"},{"name":"owner","type":"address"},{"name":"forSale","type":"bool"},{"name":"price","type":"uint256"},{"name":"rating","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"contentPolice","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"action","type":"string"},{"indexed":false,"name":"officer","type":"address"},{"indexed":false,"name":"comment","type":"string"}],"name":"squeal","type":"event"}];
var arContract = web3.eth.contract(abiArray).at(contractAddress);

When the viewer loads we want to call the “getLogo” function to get our advertisements and assign them to their respective targets. If no one is the owner of an object, we will show a “for sale sign”

console.log(“ o Assigning assets”);
for( i = 0; i < 6; i++){
console.log(“ response from contract”+arContract.getLogo(i)[0]);
if(arContract.getLogo(i)[0] != “”){
document.getElementById(“tgt”+i).innerHTML = “<a-box src = \”"+ arContract.getLogo(i)[0] + “\”></a-box>”;
} else {
document.getElementById(“tgt”+i).innerHTML = “<a-box src = \”\"></a-box> “;

More to come

This is a very simplistic system for demonstration purposes. Don’t let its simplicity fool you though, this is a live system on the public block chain. The contract can be found and interacted with at: 0x9868a675D36E2554F559771539F00Ed188A33e69 using the abi in the github repo.

ETC-public-Works – public works bots for


ETC in a Post-ASIC resistant world

For brevity in this article I use the term “Ethereum”, however this applies to all systems based on the “preDao Ethereum Prime” that spawned ETH, ETC, EXP, ELLA, and many other versions.

Process this before proceeding:

Ethereum was never ASIC proof and it is no longer ASIC resistant.


Asics for ethhash are here. They are currently and have likely been here for some time and are mining on the public chains. They are much cheaper and energy efficient than current GPU mining rigs and are only available from one source. Their construction is not opensource and no one outside of their manufacturing chain knows how they work, how they process data, or anything about them outside of what has been publicly announced by Bitmain.

Understanding the incentive model for ASIC production requires no knowledge of cryptographic hashing or wonky block chain minutia. Mining is a for profit business. Their profit is a product of their revenue minus variable costs and fixed costs. If they can lower their costs they profit more. Asics are more efficient per mh/s on electric, cheaper, and smaller, offer a clear advantage over current GPU mining rigs.

ASIC resistance is not ASIC proof

How did we get here? Why was Ethereum designed to be ASIC resistant? How was Ethereum ASIC resistant for so long?

A long time ago in a blockchain long forgotten, Ethereum was meant to use Proof of Work until the magical system of PoS was implemented back in 2016. Design and technical debt was added to the system in the form of a difficulty bomb and an ever-increasing DAG to ensure this utopian dream would happen. Both were “temporary” and intended to deter large capital investment in Ethereum mining. Both were poorly thought out for long term sustainment. The difficulty bomb has been removed by both main chains of Ethereum now as it was unproductive and more harmful than necessary. Good riddance. The DAG is something not often discussed outside of mining. The DAG is the property of the ethHash mining function that creates a need for an ever-increasing amount of memory. Memory, being very expensive to add to an ASIC, has been the limiting factor thus far in resistance. The DAG began at 1GB and is currently ~ 2.4 depending on which chain you are mining on. If you have purchased any GPU in the last 18 months you will have noticed a steep price increase at the 4gb size as these are the only cards that are now capable of handling the DAG. Any GPU card or ASIC with less than 3GB( good until April 2019) is unable to meet the current memory requirements to mine. This limits mining to high end cards and, now, ASICS. This constant DAG growth will eventually lead to a broader discussion about bus sizes/speed and memory constraints on consumer grade GPUS, but that is for another post.

For a more in depth dive into the DAG and size calculator check out:

How to effectively combat an ASICS without knowing anything about their design.

Step 1

Reset the DAG to its initial 1gb state.

Step 2

There is no step 2

Resetting the DAG to its initial state and letting it grow retains all the proprieties of ASIC resistance that have always been afforded by making ASICS non competitive on the metric of accessibility. This action would allow nearly every GPU on the planet the ability to mine, while still ensuring it is non trivial to construct ASICS. The hobbyist miners will be given a method of combating centralized ASIC miners thus allowing the community to help themselves by dusting off their old cards and rocking out.

The alternative of doing nothing and really hoping PoS comes or moving goal posts ever 6 months with new algorithms are both incredibly risky and “forky” solutions. Resetting the dag is trivial code wise and great for everyone. Unless you just spent a ton of money developing ASICs.

Simple Locking Contracts: Part 2

The Ballad of Saint Hodl

Inactivity strikes us as intelligent behavior. Neither we nor most business managers would dream of feverishly trading highly profitable subsidiaries because a small move in the Federal Reserve’s discount rate was predicted or because some Wall Street pundit had reversed his views on the market. Why, then, should we behave differently with our minority positions in wonderful businesses? — Warren Buffet

In part 1 of the series we learned about conditionally locking contracts that allow for two parties to transact value on an ethereum chain using a secret hashed password funds could be kept in public view and then retrieved at a future time. In this article, we will allow a user to send coins to a contract for safe keeping until some point in the future. In crypto trading terms this is know as “Hodling” and is an optimal strategy in investing in general( see: Warren Buffet)

The History of Hodl

In 2013, a user named GameKyuubi posted a now infamous, admittedly drunken, post on his poor luck as a trader.




GameKyuubi understood the importance of holding assets long term as a value investor, however, they lacked the strength of will to do so with the ease of trading options that were available. It is by this example that we will work on a chaincode that will allow the block chain to do the hard work “Hodling” for us.

The Saint Hodl Contracts

Saint Hodl
'-._ ```"""---.._
,-----.:___ `\ ,;;;,
'-.._ ```"""--.._ |,%%%%%% _
, '. `\;;;; -\ _ _.'/\
.' `-.__ \ ,;;;;" .__{=====/_)==:_ ||
,===/ ```";,,,,,,,;;;;;'`-./.____,'/ / '.\/
'---/ ';;;;;;;;' `--.._.' /
,===/ '-. `\/
'---/ ,'`. |
; __.-' \ ,'
jgs \______,,.....------'''`` `---`


Send funds, get later. All of the following contracts will be made available for use on for ease of access and are also available as an open source resource on github. You can use your,MEW, or any Ethereum Classic wallet to interact with them, for free!

The Most Important Part

A time locked contract cannot be opened early. You cannot negotiate with the blockchain, your locked funds are safely tucked away until the predetermined amount of blocks have passed. No backsies.

So in the time locked contract (TLC) this variable is made public and is listed first. Anyone viewing the contract should easily be able to view this number and know what they are getting into ahead of time. In sainthodl’s contract it is written as:

uint public freezeBlocks = 20;

This sets the contract freeze time up for 20 blocks, which is ~280 seconds or 4.67 minutes. Not a long time, but enough for testing. (There is a 2 million block option on site if you are looking for something more 😉 )

Freeze blocks viewed on


In part one, hash boxes were publicly view-able. The same will be true with our TLC contracts. Each ‘box’ will consist of 3 details: the owner, how long to hold coins, and how many coins are being held.

struct locker{      
uint freedom;
uint bal;
mapping (address => locker) public lockers;

Every address will now be mapped to a unique locker.

Sending funds to a Locker

Whenever anyone sends coins to our TLC contract we want it to add funds to their locker and set the freeze time to some block in the future. To do this we will be using the fall back function in the solidity contract:

function() payable public {        
locker storage l = lockers[msg.sender];
l.freedom = block.number + freezeBlocks;
l.bal = l.bal + msg.value;

The locker will be identified by the user sending funds( locker “l” is the locker of the message sender). We then use the latest block.number and add the predetermined number of freeze blocks to get our “freedom block”. The lockers balance will be calculated from its current balance (0 normally) and the value that was sent with the message. If you use the abi from the github with you will now be able to see everything in the locker (Balance will be in Wei)

Using Mew Contract interface

The Second Most Important Part: Withdrawing

Finally, the urge to panic sell has passed, and you can now safely be trusted to get your funds back. Unlike the hashlocked contract where anyone with the preimage could claim the funds, only the owner of a locker is able to withdraw their funds from the TLC. A word of caution; when allowing strangers to withdraw from a contract it is important to avoid opening up to recursive calls. The Dao contract failed because of this design flaw. This would work by someone calling the withdraw function from a contract that had its fallback function set to also call the withdraw function. To avoid this we will set the lockers balance to zero before we send any funds; this way if a contract calls back it would only be able to withdraw zero.

function withdraw() public { 
locker storage l = lockers[msg.sender];
require (block.number > l.freedom && l.bal > 0);
// avoid recursive call
uint value = l.bal;
l.bal = 0;

Similar to the first function, locker “l” is the locker of the message sender. We then require that both the current block number be greater than the lockers freedom block and that the lockers balance be greater than zero. If either of these conditions are not met, the function will ‘fail’ i.e. not do anything. If both conditions are met; the lockers balance is saved as ‘value’, the original balance is set to zero, and then value is sent to the locker owner.

Withdraw function on Mew


If you read through the contract you will notice two “events” that show up:

event Locked(address indexed locker, uint indexed amount);    
event Released(address indexed locker, uint indexed amount);

These events are displayed in wallets that watch for events and can be used to trigger things like posting to twitter.

Contract as viewed in Parity


With this simple contract anyone is able to commit and retrieve coins on the chain for as short or as long as they like. Part 3 will combine the functions of part 1 & 2 to create a hash-time locked contract to do some really cool things!