# HOW IT WORKS

Alright, this bot works by listening to the Ethereum blockchain for changes or events in particular. This is because we want to know when someone's profile is challenged by using the POH contracts. But first things first, **how** do we find out about these events?

## Waiting for the Event

By reading any of the [POH Contracts](https://github.com/Proof-Of-Humanity/Proof-Of-Humanity/tree/master/contracts), the .sol files, we found out the events are written right there! So the contracts have all of the events we may want to listen for when dealing with POH related information in the blockchain but **how** do we use them?

### Numero Zero

As we need our application to understand the smart contract, we can achieve this by [compiling the .sol contracts files to ABI .json files](https://ethereum.org/en/developers/docs/smart-contracts/compiling/) using the [Truffle](https://www.npmjs.com/package/truffle) library. Just:

```
npm i truffle
```

And then get your ABI's:

```
npx truffle compile
```

We did this in another project, but it doesn't matter. You can do it wherever you want.

Now we have the translated smart contracts! We've located them in _assets/poh-contracts_.

### Baby steps

Now, because we are using TypeScript and so we don't have to go around remembering the exact name of methods or events that pertain to any smart contract, we compile the contracts .sol files using the [TypeChain](https://github.com/ethereum-ts/TypeChain) library which provides us with typings. Pretty useful!

```
typechain --target ethers-v5 --out-dir generated/poh-ethers-contracts assets/poh-contracts/*.json
```

This sets up typechain to output to generated/poh-ethers-contracts and tells it that we are using **ethers.js-v5** and that the translated ABI contracts are in the assets/poh-contracts folder.

### Dialing up the blockchain

What is **[ethers.js](https://docs.ethers.io/v5/)** you say? A fantastic library that helps us abstract from the blockchain tech mumbo jumbo( which in time we'll learn 😅) and makes setting up a connection or listening to events pretty smooth.

Imagine if you will that you need someone to do something for you over the phone and you both speak different languages, first you need to have that person's number and you also need to know how to talk with them so they can properly follow your instructions and maybe provide feedback on whatever they are doing for you, you could use a dictionary. That's how we think about smart contracts in the blockchain.

We need their address in the blockchain to know where to contact it. We also need to know how to speak to it, and this is where we use a copy of the contract. And last, but not least we need a phone, a smart phone 😉.

### Buying a phone

Ethers let's us interact with the blockchain using what it calls **providers**, we think of them as phones. So, we set up a provider:

`const provider = new ethers.providers.JsonRpcProvider(infuraUrl)`

Here we bought a phone, but from which carrier? Well, in this project we use **Infura**. Infura gives us a connection to a node(cellphone tower) in the Ethereum blockchain. Lastly, that _JsonRpcProvider_ you could think of it as the model of the smartphone, there are more models, but this one was cheap 😛.

### Chatting with the contract

Alright, we are almost set up. Now that we have a connection to the blockchain, we need the contract's phone number and we also need to understand what they are saying and how to speak to them. To do this, we clone the contract and with a few sleepless nights make it teach us how to talk with itself. Actually, why not make the clone translate for us? That's what we do. We grab the clone and sit it with phone in hand, and we tell it to call their twin.

`const poh = Contract__factory.connect(address, provider)`

Here, the **address** is the phone number, or the location of the original contract in the blockchain. The [**provider**](https://docs.ethers.io/v5/api/providers/) is our phone, or our connection to the blockchain.

[**Contract\_\_factory**](https://docs.ethers.io/v5/api/contract/contract-factory/) is almost the same as the contract, but it has a little bit more of information to create the contract in the blockchain.

We are finally setup. The constant _poh_ or following the communication analogy, the **translator**, is the one that has access to all of the events that the real contract has. Now can call the blockchain through the translator!

## You've got mail!

Alright, the objective was to tweet when a profile was challenged, so we need that event! Searching through the .sol or ABI .json files you can find one event that is called **SubmissionChallenged** and this is the one we want. Each time a submission is challenged this event is fired. And we can easily listen to events with our recently defined _poh_ constant.

    poh.on(event, callback)

This will listen for the _event_ we provide, and execute the callback when that event is heard. To set our events, we use:

    poh.on( poh.filters.eventName(), callback)

And because we have the typings made by TypeChain, after writing _poh.filters._ every event in that Contract Factory appears before our eyes and we choose the one we need, in our case, _SubmissionChallenged()_.

## Final countdown

### Almost done

Finally! We touched the blockchain, got our event, and it delivered us some information. In the case of the SubmissionChallenged() event, we receive in the form of event.args:

- submissionID,

- requestID,

- challengeID.

Those 3 bits of information are used to query the POH API and get information on that submission, and the reason of the challenge. The query for the profile looks like this:

    query {submission(id: "${submissionId.toLowerCase()}") {
    	name
    	requests(orderBy: creationTime, orderDirection: asc) {
    		type
    		evidence(orderBy:creationTime, orderDirection: asc) {
    			URI
    		}
    		challenges {
    			reason
    			challengeID
    			disputeID
    		}
    	}
    }}`

Here we ask for information on our submissionID setting if to lower case because we had some problems by using it raw from the event, and get the most recent evidence against the profile.

Each post with evidence has a link that comes as a URI. Putting that URI after https://ipfs.io/ we get the .json with a lot of information that we need. In this way we find out the written reason of why this specific submission was challenged.

### News flash

After all of that is done, we have each piece of information we need. So now, we just tweet it 😃.

We create a Twitter account, then apply for a [dev account](https://developer.twitter.com/en) and finally, after creating an app and getting our keys we can program.

In this project we used the library [twitter-api-client](https://github.com/FeedHive/twitter-api-client) but you can use whatever you are most comfortable with.

With this library we can easily create a connection with Twitter's API:

    const  twitterClient  =  new  TwitterClient(twitterConfig)

Where twitterConfig is an object that contains:

- apiKey
- apiSecret
- accessToken
- accessTokenSecret

Which are all provided by Twitter after creating an app that can read and write.

With our _twitterClient_ in hand we just:

    twitterClient.tweets.statusesUpdate(input)

Where _input_ is an object containing the propery **status**, which is a string and is the text that will be displayed as a Tweet.

### Done

Done. We are done.


Alright, this bot works by listening to the Ethereum blockchain for changes or events in particular. This is because we want to kno...

HOW IT WORKS

# Sample note

Here's a quick sample note that shows you some of the most common use cases:

- Style text in *different* ways __*like this*__.
- Add links, like [this one](https://collectednotes.com/blog)
- Show images

![a logo](https://photos.collectednotes.com/embed.png)

- Code

```swift
let url = "collectednotes.com"
```

---

> You can learn more about **Markdown** by going to: https://www.markdownguide.org/basic-syntax/
