Prepare Vector Store

We will be using the langchain conversational retrieval chain, to use a conversational retrieval chain we need to create a vector store. To do this I used pinecone as the index for the vectors.

Create a PineCone account then create an index with the dimensions of the embeddings you will be using. In this case the dimensions are 768

First initialize pinecone make sure to do the necessary python installs to get the pinecone module

!pip install langchain==0.0.189
!pip install pinecone-client
!pip install openai
!pip install tiktoken
!pip install nest_asyncio

import pinecone 

# initialize pinecone
pinecone.init(
    api_key="PINECONE_API_KEY",  # find at app.pinecone.io
    environment="ENVIRONMENT_NAME"  # next to api key in console
)

Load the data to be used in the vector store, this example uses a pdf loader

import nest_asyncio
nest_asyncio.apply()


from langchain.document_loaders import PyPDFLoader

loader = PyPDFLoader("/Path/To/PDF")
pages = loader.load_and_split()

Split the loaded text into smaller chunks

from langchain.text_splitter import RecursiveCharacterTextSplitter
import json

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size = 1000,
    chunk_overlap  = 200,
)

docs_chunks = text_splitter.split_documents(pages)

Create the embeddings

from langchain.embeddings import HuggingFaceEmbeddings

embeddings = HuggingFaceEmbeddings(model_name='gpt2')

Create the vectors in your pinecone index

from langchain.vectorstores import Pinecone

index_name = "name of index created on pinecone"

docsearch = Pinecone.from_texts(split_text, embeddings, index_name=index_name)

Create javascript app to use the vector store

The frontend is a simple ui written in react that a user can type questions and see responses from the model. When the user types a question and then clicks on the senf button. A POST request to an endpoint within the application with the user’s question and the chat history for additional context. The backend is written in typescript.

The backend has two parts.

First, The API endpoint that calls the conversational QA chain

import { NextResponse } from 'next/server';
import {chain} from "@/utils/chain";
import {Message} from "@/types/message";

//endpoint to call the conversational qa chain
export async function POST(request: Request) {

    const body = await request.json();
    const question: string = body.query;
    const history: Message[] = body.history ?? []
  
    const res = await chain.call({
        question: question,
        chat_history: history.map(h => h.content).join("\n"),
    });

 
    return NextResponse.json({role: "assistant", content: res.text, links: ""})
}

Second, the conversational QA chain also written in typescript; it utilizes the LangChain.js package. In this example I will be using the AI21 jurassic model as the llm for the conversational retrieval chain, here are some other options.

import {pinecone} from "@/utils/pinecone-client";
import {PineconeStore} from "langchain/vectorstores/pinecone";
import {ConversationalRetrievalQAChain} from "langchain/chains";
import{AI21} from "langchain/llms/ai21"
import { HuggingFaceInferenceEmbeddings } from "langchain/embeddings/hf";

async function initChain() {
    const model = new AI21({
        model:"j2-ultra"
    })

    //initialize pinecone index
    const pineconeIndex = pinecone.Index(process.env.PINECONE_INDEX ?? '');

    /* call vectorstore*/
    const vectorStore = await PineconeStore.fromExistingIndex(
        new HuggingFaceInferenceEmbeddings({}),
        {
            pineconeIndex: pineconeIndex,
            textKey: 'text',
        },
    );

    return ConversationalRetrievalQAChain.fromLLM(
        model,
        vectorStore.asRetriever(),
        {returnSourceDocuments: true}
    );
}

export const chain = await initChain()

Run your application and you have an llm that can answer questions from the documents in your vector store.

To understand why public blockchains are important let’s look at the current method of maintaining a ledger. Whether it is the ledger of your federal government’s spending or even the database that stores your instagram account information. The problem with most ledgers today is that they tend to be a double entry system where whoever controls the books/database can always go back and edit the records without anyone being aware and with no consequences. This is why there is a multibillion dollar industry of auditors to ensure what an individual or corporation reports is on the up and up and even these auditors occasionally get it wrong see Enron.

Public blockchains solve this problem by introducing a triple entry accounting system, where after a few confirmations it is highly improbable a transaction entered in the ledger can be edited or reversed, instead of having human auditors who might get it wrong the nodes that verify transactions are the auditors ensuring the transaction meets the protocols requirements before it is recorded in the ledger. This, to me is ultimately one of the key changes introduced by public blockchains. you can trust what you are seeing is the truth and has not been altered.

The potential this presents to change how we fundamentally interact as a species is immense.

If you own crypto assets worth more than $200 and you have made the decision to self-custody, you should absolutely own a hardware wallet! Hot wallets are just not good enough!

With Hot Wallets such as a metamask wallet, if the password for the account or email address is compromised, the keys may also be compromised and a bad actor can sign transactions without the owner knowing.

However with cold wallets the keys never leave the wallet and any transaction that need to be signed with the keys in the wallet need the user to physically interact with the wallet.

The two top choices are Trezor or Ledger. Personally, I prefer the Trezor for its simplicity.

Pro Tip: Keep your main stash in the cold wallet and use the hot wallet for day to day interactions or experiments. Also never enter your seed phrase anywhere!

Bank accounts are useful because they made it easier for people to manage their cashflows without having to touch physical cash, however, the user still has no way of knowing for sure whether the current balance they see on the screen is real till they try to redeem their funds.

Blockchain assets are useful because the owner can take custody of their assets by using a hot or a cold wallet with minimal physical constraints. The balance of this wallet is also easily verifiable by checking the address on your preferred block explorer or you can participate in the network by running a node which can also check balances.

Traditional financial primitives such as swaps, yield farming, borrowing and lending being facilitated by blockchains and their asset enable the individual to retain full control of their assets while using these primitives. The implications of this might impact how individuals interact with traditional bank accounts and the existing methods of accessing the associated primitives.

What better way to make sure the cryptocurrency you just bought isn’t all smoke and mirrors than running your own node and participating in the network.

However, depending on the computing requirements of the protocol and the length of time the protocol has been running, it can become difficult for most people to run computers or buy enough storage to keep up with the information stored in the chain. i.e. is the protocol socially scalable(easy for most people to run a node) or computationally scalable(can handle a large throughput but requires special computers most cannot afford).

The current size of the Ethereum Classic ledger is about 300GB and it can be run on a computer with 4GB of RAM. The storage will have to be a SSD drive as mechanical drives can not keep up with the disk read/write requirements of mainnet.

PS: I initially tried syncing to the tip of the chain which was about block 14,000,000 with a mechanical drive. it’s been a week and I am only at block 3,000,000.

My Setup

• Computer: 16GB RAM M1 Mac Mini

• Ethereum Classic Client: Hyperledger Besu, this guide explains how to setup the node

• Storage: Samsung T7 SSD

Things you’ll need. This list is not extensive and will depend on how much metadata you want your token to have

1. The image file

2. The image name

3. The image description

4. An IPFS path for the image e.g. ipfs://QmVDae8m3X6HZf9v2Jnyqe53Xpj64vEvQDUci1NpX1Krcs

The first thing you’ll need to do is upload the image to an IPFS node. You can create a pinata account to do this. Once the image is uploaded and pinned on Pinata you will get a CID that looks like this ‘QmVDae8m3X6HZf9v2Jnyqe53Xpj64vEvQDUci1NpX1Krcs’

Then create the json file that will contain the metadata. e.g. the metadata defined below only has three fields - name, description and image.

Upload the json file to a folder on an IPFS node as well, you will also have a CID for the file. Once this is done your token URI will be in the format https://ipfs.io/ipfs/folderCID/metadata.json . This URI can now be used to mint your token

There are two ways I know of that you can interact with a smart contract on Ethereum Classic without the client side.

The First - Blockscout

In blockscout find the contract address for the application and then go to the write section of the contract address e.g. the write section of this NFT smart contract. All of the write functions available on the client side will be accessible.

The Second - MyEtherWallet

You can also interact with the smart contract using its ABI and the contract address. To do this:

1. Connect your Ethereum Classic wallet to myetherwallet

2. Go to the contract section and click on interact with contract

3. Enter the smart contracts ABI and contract address

4. On the next screen you will have access to all the available write functions in the smart contract

The invention of Bitcoin has shown that the issuance of a digitally native means of exchange can be done without any trust assumptions for its issuance schedule or the balances of its participants. There are many working parts that makes this possible but the main part is Nakamoto Consensus. Most digital assets backed by a blockchain can be assigned a dollar value because they are traded on some type of cryptocurrency exchange and hence go through the price discovery process(some say this somewhat cheapens the assets by only looking at its dollar value).

Then Ethereum came along, also with the ability to issue digitally native means of exchanges as well as a public ledger of transactions. This time however, you can write any software application you can think of and deploy it to the blockchain. The implications of this are significant. Decentralized blockchains are trustless and permissionless meaning anyone, anywhere in the world can deploy a smart contract to Ethereum Mainnet and is able to start generating income from that application without having to ask for access or file any sort of documentations.

For as long as the Ethereum blockchain stays active, the user’s application can not be censored or de-platformed. Many many more verticals will arise from this but the largest of them today is the decentralized financial applications we see today that enable asset swaps and lending.

If you’re like me and counting your coins, for low priority transactions, you can edit how much gas you’re willing to pay for the transaction through Metamask. This sounds nice if you could keep sending limit gwei transactions where the sequence the transaction was submitted does not affect the execution order; you would never have to pay high gas fees again. However, because of something called a transaction nonce, this is not possible.

A nonce is what the Ethereum Virtual Machine uses to keep track of the number of transactions an address has sent, the virtual machine does not let a pending transaction with a higher nonce execute before one with a lower nonce e.g. transaction with nonce 2 will not execute before a transaction with nonce 1.

To prevent losing this image due to unforeseen reasons the simplest way would just be to right-click + save to your computer. Another way would be to also setup an IPFS node and pin the images.

To do this:

1. Download and Install IPFS Here

2. Initialize IPFS and run the daemon with This

3. Once your daemon is running use the Web Console at the webui url to upload your files

4. Pin these files to your local node

On a decentralized exchange this liquidity/depth can be provided by anyone with an internet connection, a web3 wallet and some money. These market makers are paid for their services in the fees earned from each client trade. Transactions on the biggest decentralized finance blockchains are broadcast before they are included in a block, this also provides an opportunity to see client trades as they happen. This time though, anyone can take advantage of this, not just market makers.

The impact this may have on how we raise/pool funds as a society will likely be significant. Finance is currently the most popular application of how decentralized blockchains can democratize access to economic activity, in the coming years, there will likely be many more applications.

In the crypto economy these incentives are typically in the form of digital tokens. These tokens do not all have the same function or distribution mechanism, however once the tokens can be traded, a price or perceived value can be determined as exchanges are just an aggregate of demand and supply orders which determine price in whatever the token is traded for.

Digital Token functions can be broadly classified as

Native Tokens

These tokens come with the blockchain or the protocol and help pay for transaction fees as well as reward users that participate in the protocol. The way users can participate and how participants are rewarded in the native token varies from one protocol to another and depends on what the protocol is trying to facilitate.

Governance Tokens

Native tokens can be governance tokens but not all governance tokens are native tokens. Like the name implies these tokens grant holders the ability to vote on protocol improvement proposals. The more governance tokens a user has the more votes they get.

Liquidity Pool Tokens

Liquidity pool tokens are issued when a user contributes to a liquidity pool. The number of LP tokens the user receives represents how much liquidity contributed to the pool and how much of the pool fees they earn.

Non Fungible Tokens

All previously mentioned tokens are fungible i.e. are interchangeable. Non Fungible Tokens represent items that are one of one i.e. not interchangeable. The most popular NFT application is currently digital art, however the potential applications are many. For example a birth certificate, or a driver’s license can be represented as an NFT.

The thesis for this bet starts with the Bitcoin protocol. The Bitcoin protocol enables the consistent decentralized issuance of a digital token(bitcoin) which can be used as means of exchange and can hold its value over a period of time. Digital currencies have been created before bitcoin but there was always the problem of keeping an accurate track of how much of the available tokens each participant owns in a decentralized/trustless manner. The Bitcoin protocol solves this with its proof of work algorithm to obtain consensus on processed transactions and update participant balances. Based on known human history, the creation of accepted means of exchanges has rarely been outside the control of a few people sitting in a room. Trust is implicitly defined in this process and also the backing of violence is required. The implications of having a digital, open, trustless and permissionless monetary supply will be significant and far reaching.

Building on this innovation, the Ethereum protocol was created. The Ethereum blockchain is also open, trustless and permissionless with its own native token, the ether. What makes it different from the Bitcoin protocol is that it has a virtual machine that can run code. This code can be written and deployed to the Ethereum blockchain by anyone with a computer and an internet connection. Reading from the Ethereum blockchain is free, however writing to it will have an associated cost as writing to the Ethereum blockchain typically involves a state change which can be thought of as a transaction that needs to be included in a block so the blockchain has the most recent state of its participants.

After its launch in 2015, Ethereum is currently the dominant smart contract platform and the Ethereum Virtual Machine (EVM) / Solidity appears to be the smart contract standard. The Ethereum blockchain, its side-chains, L2s and rollups lead all other smart contract platforms and ecosystems in economic security, total value locked, developer contributions, daily transactions, active users and many more metrics.

Where does Ethereum Classic fit in? Ethereum Classic is the original Ethereum blockchain. In 2016, there was an application(smart contract) deployed to the Ethereum blockchain which was exploited, resulting in some participants losing their funds. When this exploit happened, some of the Ethereum community decided to make the participants who lost funds whole and forked the blockchain to create what is called Ethereum today. The rest of the community did not agree with this and continued to maintain the blockchain where participants were not refunded. This blockchain is called Ethereum Classic.

A case for Ethereum Classic

Ethereum’s success will be Ethereum Classic’s success. I believe Ethereum Classic will benefit from the EVM/solidity being the smart contract standard as a significant number of developers can write solidity and even the competing smart contract platforms typically build in EVM compatibility. There is also a significant amount of effort that has gone into auditing and ensuring code security assurances for solidity smart contracts.

Ethereum Classic will also likely benefit from the Ethereum blockchain’s migration to Proof of Stake. Both blockchains are currently Proof of Work blockchains and use the same mining algorithm. It stands to reason the miners from Ethereum looking for other profitable opportunities will mine Ethereum Classic increasing the security and money soundness guarantees of the Ethereum Classic blockchain.

Finally, it appears the modular blockchain approach is the most effective way to scale transactions on decentralized blockchains i.e. separating consensus, data availability and execution. Ethereum Classic stands to benefit from this by serving as an economic security/consensus layer for execution environments(read rollups) or even other blockchains that do not want to bootstrap their own security and consensus network.

Utility/Adoption

Nothing says this new project/protocol might survive one or several bear markets and continue to grow through them like adoption from other crypto projects and a continually growing developer community as well as a real world use case. Utility is not strictly necessary however, as can be seen with Doge, sometimes community is more important.

Market Capitalization

Market caps are more of a reference point as this is all new and it is difficult to accurately say how big these projects can get. However, when trying to narrow down your investment decision, the lower the market cap the larger the potential upside. The larger the market cap, the investment poses less risk but also has less upside.

Circulating Supply

Protocols with a maximum supply of less than 1billion units are a digital scarcity dream. I try to optimize for coins with small supplies. There are exceptions to this however, if the protocol has a large supply of tokens but has useful mechanisms to lock up or burn these tokens to control potential sell pressure; this is also a good sign.

Interoperability

We live in a multi-chain world. User experience still has a long way to go when trying to move assets or transact from one blockchain to another. I firmly believe in a few years most users may not even know which chain they are using. Chain selection will be abstracted away by better and better user experiences. Protocols that facilitate a smooth multi-chain world have the potential to generate significant value.

Income

Income or staking rewards are a good way to hedge against negative price action. This income is usually in the form of a reward in the protocols native token; if the user locks up their tokens for a certain amount of time.