stack-orchestrator/app/data/stacks/erc20/README.md

ERC20 Watcher

Instructions to deploy a local ERC20 watcher stack (core + watcher) for demonstration and testing purposes using stack orchestrator

Setup

Clone required repositories:

laconic-so setup-repositories --include cerc-io/go-ethereum,cerc-io/ipld-eth-db,cerc-io/ipld-eth-server,cerc-io/watcher-ts 

Build the core and watcher container images:

laconic-so build-containers --include cerc/go-ethereum,cerc/go-ethereum-foundry,cerc/ipld-eth-db,cerc/ipld-eth-server,cerc/watcher-erc20

This should create the required docker images in the local image registry.

Deploy the stack:

laconic-so deploy-system --include ipld-eth-db,go-ethereum-foundry,ipld-eth-server,watcher-erc20 up

Demo

Find the watcher container's id using docker ps and export it for later use:

export CONTAINER_ID=<CONTAINER_ID>

Deploy an ERC20 token:

docker exec $CONTAINER_ID yarn token:deploy:docker

Export the address of the deployed token to a shell variable for later use:

export TOKEN_ADDRESS=<TOKEN_ADDRESS>

Open http://localhost:3002/graphql (GraphQL Playground) in a browser window

Connect MetaMask to http://localhost:8545 (with chain ID 99)

Add the deployed token as an asset in MetaMask and check that the initial balance is zero

Export your MetaMask account (second account) address to a shell variable for later use:

export RECIPIENT_ADDRESS=<RECIPIENT_ADDRESS>

To get the primary account's address, run:

docker exec $CONTAINER_ID yarn account:docker

To get the current block hash at any time, run:

docker exec $CONTAINER_ID yarn block:latest:docker

Fire a GQL query in the playground to get the name, symbol and total supply of the deployed token:

query {
  name(
    blockHash: "LATEST_BLOCK_HASH"
    token: "TOKEN_ADDRESS"
  ) {
    value
    proof {
      data
    }
  }

  symbol(
    blockHash: "LATEST_BLOCK_HASH"
    token: "TOKEN_ADDRESS"
  ) {
    value
    proof {
      data
    }
  }

  totalSupply(
    blockHash: "LATEST_BLOCK_HASH"
    token: "TOKEN_ADDRESS"
  ) {
    value
    proof {
      data
    }
  }
}

Fire the following query to get balances for the primary and the recipient account at the latest block hash:

query {
  fromBalanceOf: balanceOf(
      blockHash: "LATEST_BLOCK_HASH"
      token: "TOKEN_ADDRESS",
      # primary account having all the balance initially
      owner: "PRIMARY_ADDRESS"
    ) {
    value
    proof {
      data
    }
  }
  toBalanceOf: balanceOf(
      blockHash: "LATEST_BLOCK_HASH"
      token: "TOKEN_ADDRESS",
      owner: "RECIPIENT_ADDRESS"
    ) {
    value
    proof {
      data
    }
  }
}

• The initial balance for the primary account should be 1000000000000000000000
• The initial balance for the recipient should be 0

Transfer tokens to the recipient account:

docker exec $CONTAINER_ID yarn token:transfer:docker --token $TOKEN_ADDRESS --to $RECIPIENT_ADDRESS --amount 100

Fire the above GQL query again with the latest block hash to get updated balances for the primary (from) and the recipient (to) account:

• The balance for the primary account should be reduced by the transfer amount (100)
• The balance for the recipient account should be equal to the transfer amount (100)

Transfer funds between different accounts using MetaMask and use the playground to query the balance before and after the transfer.

Clean up

To stop all the services running in background run:

laconic-so deploy-system --include ipld-eth-db,go-ethereum-foundry,ipld-eth-server,watcher-erc20 down