add logger, deno tasks, and README to examples

cli/start/mod.ts

@@ -10,6 +10,8 @@ import { ArkiverMetadata } from '../../src/arkiver/arkive-metadata.ts'
 import { createManifestHandlers } from './logger.ts'
 import { colors, mongoose, SchemaComposer } from '../../src/deps.ts'
 import { logger } from '../../src/logger.ts'
+import { supportedChains } from '../../src/chains.ts'
+
 
 export const action = async (
   options: {
@@ -113,12 +115,34 @@ export const action = async (
       ...loggers,
     },
   })
+
+  if(options.rpcUrl && !Array.isArray(options.rpcUrl)){
+    options.rpcUrl = [options.rpcUrl]
+  }
+
+   const getEnv = (key: string, defaultValue?: string): string => {
+    const value = Deno.env.get(key)
+    if (!value && !defaultValue) {
+      throw new Error(`Missing environment variable: ${key}`)
+    }
+    return value || defaultValue || ''
+  }
+
+  const collectRpcUrls = () => {
+    const rpcUrls: Record<string, string> = {}
+    for (const chain of Object.keys(supportedChains)) {
+      try {
+        rpcUrls[chain] = getEnv(`${chain.toUpperCase()}_RPC_URL`)
+      } catch (e) {}
+    }
+    return rpcUrls
+  }
 
   const rpcUrls = options.rpcUrl?.reduce((acc, rpc) => {
     const [name, url] = rpc.split('=')
     acc[name] = url
     return acc
-  }, {} as Record<string, string>) ?? {}
+  }, {} as Record<string, string>) ?? collectRpcUrls() ?? {}
 
   logger('arkiver').debug(`Connecting to database...`)
   const connectionString = options.mongoConnection ??

examples/block-handler-vaults/README.md

@@ -0,0 +1,38 @@
+# ERC20 Balance History
+This Arkive keeps an accurate historical record of the sharePrice of a given set of YearnV2 Abi Vaults. sharePrice increases as profits are distributed to the vaults, but may also decrease if loss is incurred. It may be valuable to track this information in case of incidents or in order to optimize the vaults for instance. 
+### Dependencies
+* Docker
+* Historical RPC (Infura, Ankr, Alchemy, etc)
+
+### Arkive Usage
+
+First make sure scripts/.env is configured correctly with your RPC endpoint. In this example we are connecting the `mainnet` with the Ankr public ETH endpoint.
+> RPC_URL=mainnet=https://rpc.ankr.com/eth
+
+All available tasks can been seen with
+> deno task
+
+To start a new instance of the Arkive you can use `deno task` to run the `new` script with the following command
+> deno task new
+
+To reset the database and resync the Arkive run `reset` task
+> deno task reset
+
+### Using the GraphQL Explorer
+If Arkiver is running there should now be webpage avaiable at http://0.0.0.0:4000/graphql
+
+In the left side you can use the no-code explorer to pick and chose which Entities and what fields of the Entities you would like to look at. Here is an example query for this Arkive. This fetches the latest VaultSnapshot entity.
+```
+query MyQuery {
+  VaultSnapshot(sort: _ID_DESC) {
+    vault
+    name
+    symbol
+    block
+    timestamp
+    sharePrice
+  }
+}
+```
+
+

examples/block-handler-vaults/deno.jsonc

@@ -0,0 +1,13 @@
+{
+    "tasks": {
+      "start": "arkiver start ./ -c mongodb://localhost:27017",
+      "new": "docker run --name mongo -d -p 27017:27017 mongodb/mongodb-community-server:latest && arkiver start ./ -c mongodb://localhost:27017",
+      "resetdb": "docker stop mongo && docker rm mongo && docker run --name mongo -d -p 27017:27017 mongodb/mongodb-community-server:latest",
+      "reset": "scripts/resetdb.sh && arkiver start ./ -c mongodb://localhost:27017",
+      "newdb": "docker run --name mongo -d -p 27017:27017 mongodb/mongodb-community-server:latest",
+      "stopdb": "docker stop mongo",
+      "rmdb": "docker rm mongo",
+      "startdb": "docker start mongo",
+      "deploy": "arkiver deploy ./"
+    }
+  }

examples/block-handler-vaults/handlers/vault.ts

@@ -12,6 +12,7 @@ export const snapshotVault: BlockHandler = async ({
   block,
   client,
   store,
+  logger
 }): Promise<void> => {
   // Filter out vaults that haven't been deployed yet
   const liveVaults = VAULTS.filter((e) => e.block < Number(block.number))
@@ -54,16 +55,19 @@ export const snapshotVault: BlockHandler = async ({
 
   // Save the vault snapshots
   vaults.map((vault, i) => {
+    const sharePrice = parseFloat(
+      formatUnits(sharePrices[i], Number(vault.decimals)),
+    )
+    logger.info(`${vault.name} share price updated to ${sharePrice}`)
     return new VaultSnapshot({
-      id: `${vault.address}-${Number(block.number)}`,
+     // id: `${vault.address}-${Number(block.number)}`,
       block: Number(block.number),
       timestamp: Number(block.timestamp),
       vault: vault.address,
-      sharePrice: parseFloat(
-        formatUnits(sharePrices[i], Number(vault.decimals)),
-      ),
+      sharePrice: sharePrice,
       name: vault.name,
       symbol: vault.symbol,
     })
+
   }).map((e) => e.save())
 }

examples/erc20-balance-history/README.md

@@ -0,0 +1,41 @@
+# ERC20 Balance History
+This Arkive keeps an accurate historical record of the balance of an account of a given ERC20 token. It uses the Balance entity as a mutable variable updates as events are handled and is used to keep track of an accounts balance as we sync eventually reflecting true onchain balance. BalanceHistory is an unchanging entity which stores balance over time and is indexed by the `block` field. 
+### Dependencies
+* Docker
+* Historical RPC (Infura, Ankr, Alchemy, etc)
+
+### Arkive Usage
+
+First make sure scripts/.env is configured correctly with your RPC endpoint. In this example we are connecting the `mainnet` with the Ankr public ETH endpoint.
+> RPC_URL=mainnet=https://rpc.ankr.com/eth
+
+All available tasks can been seen with
+> deno task
+
+To start a new instance of the Arkive you can use `deno task` to run the `new` script with the following command
+> deno task new
+
+To reset the database and resync the Arkive run `reset` task
+> deno task reset
+
+### Using the GraphQL Explorer
+If Arkiver is running there should now be webpage avaiable at http://0.0.0.0:4000/graphql
+
+In the left side you can use the no-code explorer to pick and chose which Entities and what fields of the Entities you would like to look at. Here is an example query for this Arkive. This fetches the latest Balance and BalanceHistory entities.
+```
+query MyQuery {
+  Balance(sort: _ID_DESC) {
+    token
+    user
+    balance
+  }
+  BalanceHistory(sort: _ID_DESC) {
+    token
+    block
+    user
+    balance
+  }
+}
+```
+
+

examples/erc20-balance-history/deno.jsonc

@@ -0,0 +1,13 @@
+{
+    "tasks": {
+      "start": "arkiver start ./ -c mongodb://localhost:27017",
+      "new": "docker run --name mongo -d -p 27017:27017 mongodb/mongodb-community-server:latest && arkiver start ./ -c mongodb://localhost:27017",
+      "resetdb": "docker stop mongo && docker rm mongo && docker run --name mongo -d -p 27017:27017 mongodb/mongodb-community-server:latest",
+      "reset": "scripts/resetdb.sh && arkiver start ./ -c mongodb://localhost:27017",
+      "newdb": "docker run --name mongo -d -p 27017:27017 mongodb/mongodb-community-server:latest",
+      "stopdb": "docker stop mongo",
+      "rmdb": "docker rm mongo",
+      "startdb": "docker start mongo",
+      "deploy": "arkiver deploy ./"
+    }
+  }

examples/erc20-balance-history/entities.ts

@@ -16,15 +16,15 @@ export const Transfer = createEntity('Transfer', {
 export const Balance = createEntity('Balance', {
   token: String,
   user: String,
-  balance: Number,
+  balance: String,
 })
 
 // Contains all balance changes for every user
 export const BalanceHistory = createEntity('BalanceHistory', {
   token: String,
   block: { type: Number, index: true },
   user: String,
-  balance: Number,
+  balance: String,
 })
 
 export const Entities = [Balance, BalanceHistory, Transfer]

examples/erc20-balance-history/handlers.ts

@@ -1,19 +1,31 @@
-import { formatUnits } from 'npm:viem'
+import { formatUnits, numberToHex, fromHex } from 'npm:viem'
 import { type EventHandlerFor } from 'https://deno.land/x/robo_arkiver@v0.4.17/mod.ts'
 import erc20 from './erc20.ts'
 import { Balance, BalanceHistory, Transfer } from './entities.ts'
 
 // Alternatively, you can pull this from the chain
 const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
 
-const getBalance = async (user: string, token: string) => {
+const getBalance = async (user: string, token: string, client, block, store) => {
   const bal = await Balance.findOne({ user })
-  if (bal) return bal
-  return new Balance({ user, token, balance: 0 })
+  if (bal){
+    return bal
+  } else {
+    let userBalance = await client.readContract({
+			address: token,
+			abi: erc20,
+			functionName: 'balanceOf',
+			blockNumber: block.blockNumber,
+      args: [user]
+		})
+    return new Balance({ user, token, balance: numberToHex(userBalance) })
+  }
+
+
 }
 
 export const onTransfer: EventHandlerFor<typeof erc20, 'Transfer'> = async (
-  { event, store, client },
+  { event, store, client, logger },
 ) => {
   // Store the transfer event
   const { from, to, value } = event.args
@@ -40,17 +52,23 @@ export const onTransfer: EventHandlerFor<typeof erc20, 'Transfer'> = async (
   })
   record.save()
 
-  const updateBalance = async (user: string, value: number) => {
+  const updateBalance = async (user: string, value: bigint, client, block, store) => {
     // ignore zero address
     if (user === ZERO_ADDRESS) {
       return
     }
 
     // grab the balance entry for the user
-    const bal = await getBalance(user, address)
-
+    let bal = new Balance({})
+    try{
+      bal = await getBalance(user, address, client, block, store)
+    } catch(e){
+      logger.error(`getBalance error: ${e}`)
+      return
+    }
+
     // adjust the value
-    bal.balance += value
+    bal.balance = numberToHex(fromHex(bal.balance, 'bigint') + value)
 
     // Create a BalanceHistory entry to record
     // historic changes in the balance
@@ -60,6 +78,7 @@ export const onTransfer: EventHandlerFor<typeof erc20, 'Transfer'> = async (
       user,
       balance: bal.balance,
     })
+    logger.info(`Balance of ${user} updated to ${bal.balance} at block ${block} on ${address}`)
 
     // Save both the balance and the history entry
     return Promise.all([
@@ -71,9 +90,8 @@ export const onTransfer: EventHandlerFor<typeof erc20, 'Transfer'> = async (
   // Update the balances for both the sender and the receiver
   // note: user await here to ensure the handler is synchonous
   // 		 so te balances are updated
-  const amount = Number(formatUnits(value, Number(decimals)))
   await Promise.all([
-    updateBalance(from, -amount),
-    updateBalance(to, amount),
+    updateBalance(from, -value, client, block, store),
+    updateBalance(to, value, client, block, store),
   ])
 }

examples/erc20-events/README.md

@@ -0,0 +1,44 @@
+# ERC20 Events Arkive
+This Arkive has two entities, Transfer and Approval. The Arkive also has two corresponding event handlers onTransfer and onApproval which are triggered when the `Transfer` and `Approval` events are emitted by the source contract which is configured to `WETH` in the manifest. When the handlers are triggered they parse the amount and store either an Approval or Transfer entity in the database.
+### Dependencies
+* Docker
+* Historical RPC (Infura, Ankr, Alchemy, etc)
+
+### Arkive Usage
+
+First make sure scripts/.env is configured correctly with your RPC endpoint. In this example we are connecting the `mainnet` with the Ankr public ETH endpoint.
+> RPC_URL=mainnet=https://rpc.ankr.com/eth
+
+All available tasks can been seen with
+> deno task
+
+To start a new instance of the Arkive you can use `deno task` to run the `new` script with the following command
+> deno task new
+
+To reset the database and resync the Arkive run `reset` task
+> deno task reset
+
+### Using the GraphQL Explorer
+If Arkiver is running there should now be webpage avaiable at http://0.0.0.0:4000/graphql
+
+In the left side you can use the no-code explorer to pick and chose which Entities and what fields of the Entities you would like to look at. Here is an example query for this Arkive.
+```
+query MyQuery {
+  Approval {
+    block
+    hash
+    owner
+    spender
+    value
+  }
+  Transfer {
+    block
+    hash
+    from
+    to
+    value
+  }
+}
+```
+
+

examples/erc20-events/deno.jsonc

@@ -0,0 +1,13 @@
+{
+    "tasks": {
+      "start": "arkiver start ./ -c mongodb://localhost:27017",
+      "new": "docker run --name mongo -d -p 27017:27017 mongodb/mongodb-community-server:latest && arkiver start ./ -c mongodb://localhost:27017",
+      "resetdb": "docker stop mongo && docker rm mongo && docker run --name mongo -d -p 27017:27017 mongodb/mongodb-community-server:latest",
+      "reset": "scripts/resetdb.sh && arkiver start ./ -c mongodb://localhost:27017",
+      "newdb": "docker run --name mongo -d -p 27017:27017 mongodb/mongodb-community-server:latest",
+      "stopdb": "docker stop mongo",
+      "rmdb": "docker rm mongo",
+      "startdb": "docker start mongo",
+      "deploy": "arkiver deploy ./"
+    }
+  }

examples/erc20-events/handlers.ts

@@ -8,7 +8,7 @@ const TOKEN_DECIMALS = 18
 
 // deno-lint-ignore require-await
 export const onTransfer: EventHandlerFor<typeof erc20, 'Transfer'> = async (
-  { event },
+  { event, logger },
 ) => {
   const { from, to, value } = event.args
   const block = Number(event.blockNumber)
@@ -20,20 +20,25 @@ export const onTransfer: EventHandlerFor<typeof erc20, 'Transfer'> = async (
     value: formatUnits(value, TOKEN_DECIMALS),
   })
   record.save()
+  const parsedValue = parseFloat(formatUnits(value, TOKEN_DECIMALS))
+  logger.info(`Transfer of ${parsedValue} from ${from} to ${to} on ${event.address}`)
 }
 
 // deno-lint-ignore require-await
 export const onApproval: EventHandlerFor<typeof erc20, 'Approval'> = async (
-  { event },
+  { event, logger },
 ) => {
   const { owner, spender, value } = event.args
   const block = Number(event.blockNumber)
+  const parsedValue = parseFloat(formatUnits(value, TOKEN_DECIMALS))
   const record = new Approval({
     hash: event.transactionHash,
     block,
     owner,
     spender,
-    value: formatUnits(value, TOKEN_DECIMALS),
+    value: parsedValue,
   })
   record.save()
+
+  logger.info(`Approval of ${parsedValue} from ${owner} to ${spender} on ${event.address}`)
 }