Add block height in relevant adapters

.github/strategy/adapters.json

@@ -106,7 +106,8 @@
       "defi-pulse",
       "dns-record-check",
       "outlier-detection",
-      "crypto-volatility-index"
+      "crypto-volatility-index",
+      "bitcoin-json-rpc"
     ]
   },
   "synth-index": {

CHANGELOG.md

@@ -25,6 +25,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
   - `paxos` to get Paxos asset supply attestations
   - `outlier-detection`: composite adapter to check for outlier values between multiple sets of data providers
   - `dydx-stark` to sign the input price data with your private STARK key, and send it to the destination endpoint.
+  - `bitcoin-json-rpc`: composite adapter for querying bitcoin blockchain stats(difficulty, height) according to the existing convention
 - Added support for metadata in requests. This gives adapters access to the FM on-chain round state.
 - Moves re-usable test behaviors & testing utils to a new package - `@chainlink/adapter-test-helpers`
 - Added support for using query string parameters as input to adapters.

blockchair/README.md

@@ -9,11 +9,8 @@ The adapter takes the following environment variables:
 
 ## Input Params
 
-- `endpoint`: The endpoint to use, one of (difficulty|balance). Defaults to `difficulty`
-
-### Difficulty endpoint
-
-- `blockchain` or `coin`: The blockchain to get difficulty from
+- `blockchain` or `coin`: The blockchain to get stats from
+- `endpoint`: The parameter to query for. Default: "difficulty"
 
 ### Output
 

blockchair/src/adapter.ts

@@ -1,7 +1,7 @@
 import { Requester, Validator, AdapterError } from '@chainlink/external-adapter'
 import { ExecuteWithConfig, ExecuteFactory, Config } from '@chainlink/types'
 import { makeConfig, DEFAULT_ENDPOINT } from './config'
-import { difficulty, balance } from './endpoint'
+import { stats, balance } from './endpoint'
 
 const inputParams = {
   endpoint: false,
@@ -18,8 +18,10 @@ const execute: ExecuteWithConfig<Config> = async (request, config) => {
   const endpoint = validator.validated.data.endpoint || DEFAULT_ENDPOINT
 
   switch (endpoint) {
-    case difficulty.Name: {
-      return difficulty.execute(request, config)
+    // might be moved to validator or config
+    case 'difficulty':
+    case 'height': {
+      return stats.execute(request, config)
     }
     case balance.Name: {
       return balance.makeExecute(config)(request)

blockchair/src/endpoint/index.ts

@@ -1,5 +1,5 @@
 export * as balance from './balance'
-export * as difficulty from './difficulty'
+export * as stats from './stats'
 
 export const COIN_KEYS = ['btc', 'dash', 'doge', 'ltc', 'bch'] as const
 export type CoinType = typeof COIN_KEYS[number]

blockchair/src/endpoint/difficulty.ts → blockchair/src/endpoint/stats.ts

@@ -1,17 +1,25 @@
 import { Requester, Validator } from '@chainlink/external-adapter'
 import { ExecuteWithConfig, Config } from '@chainlink/types'
 import { COINS } from '.'
+import { DEFAULT_ENDPOINT } from '../config'
 
-export const Name = 'difficulty'
+export const Name = 'stats'
 
 const inputParams = {
   blockchain: ['blockchain', 'coin'],
+  endpoint: false,
+}
+
+const convertEndpoint: { [key: string]: string } = {
+  height: 'blocks',
 }
 
 export const execute: ExecuteWithConfig<Config> = async (input, config) => {
   const validator = new Validator(input, inputParams)
   if (validator.error) throw validator.error
   const jobRunID = validator.validated.id
+  let endpoint = validator.validated.data.endpoint || DEFAULT_ENDPOINT
+  if (endpoint in convertEndpoint) endpoint = convertEndpoint[endpoint]
 
   const blockchain = Requester.toVendorName(
     validator.validated.data.blockchain.toLowerCase(),
@@ -22,6 +30,6 @@ export const execute: ExecuteWithConfig<Config> = async (input, config) => {
   const reqConfig = { ...config.api, url }
 
   const response = await Requester.request(reqConfig)
-  response.data.result = Requester.validateResultNumber(response.data, ['data', 'difficulty'])
+  response.data.result = Requester.validateResultNumber(response.data, ['data', endpoint])
   return Requester.success(jobRunID, response)
 }

blockchair/test/stats.test.ts

@@ -0,0 +1,90 @@
+import { assert } from 'chai'
+import { Requester, AdapterError } from '@chainlink/external-adapter'
+import { assertSuccess, assertError } from '@chainlink/adapter-test-helpers'
+import { AdapterRequest } from '@chainlink/types'
+import { makeExecute } from '../src/adapter'
+
+describe('stats endpoint', () => {
+  const jobID = '1'
+  const execute = makeExecute()
+
+  context('successful calls @integration', () => {
+    const requests = [
+      {
+        name: 'id not supplied',
+        testData: { data: { blockchain: 'BTC' } },
+      },
+      {
+        name: 'blockchain',
+        testData: { id: jobID, data: { blockchain: 'BTC' } },
+      },
+      {
+        name: 'coin',
+        testData: { id: jobID, data: { coin: 'BTC' } },
+      },
+      {
+        name: 'blockchain difficulty with endpoint',
+        testData: { id: jobID, data: { blockchain: 'BTC', endpoint: 'difficulty' } },
+      },
+      {
+        name: 'coing difficulty with endpoint',
+        testData: { id: jobID, data: { coin: 'BTC', endpoint: 'difficulty' } },
+      },
+      {
+        name: 'blockchain height',
+        testData: { id: jobID, data: { blockchain: 'BTC', endpoint: 'height' } },
+      },
+      {
+        name: 'coin height',
+        testData: { id: jobID, data: { coin: 'BTC', endpoint: 'height' } },
+      },
+    ]
+
+    requests.forEach((req) => {
+      it(`${req.name}`, async () => {
+        const data = await execute(req.testData as AdapterRequest)
+        assertSuccess({ expected: 200, actual: data.statusCode }, data, jobID)
+        assert.isAbove(data.result, 0)
+        assert.isAbove(data.data.result, 0)
+      })
+    })
+  })
+
+  context('validation error', () => {
+    const requests = [
+      { name: 'empty body', testData: {} },
+      { name: 'empty data', testData: { data: {} } },
+    ]
+
+    requests.forEach((req) => {
+      it(`${req.name}`, async () => {
+        try {
+          await execute(req.testData as AdapterRequest)
+        } catch (error) {
+          const errorResp = Requester.errored(jobID, new AdapterError(error))
+          assertError({ expected: 400, actual: errorResp.statusCode }, errorResp, jobID)
+        }
+      })
+    })
+  })
+
+  context('error calls @integration', () => {
+    const requests = [
+      {
+        name: 'unknown blockchain',
+        testData: { id: jobID, data: { blockchain: 'not_real' } },
+      },
+    ]
+
+    requests.forEach((req) => {
+      it(`${req.name}`, async () => {
+        try {
+          await execute(req.testData as AdapterRequest)
+        } catch (error) {
+          const errorResp = Requester.errored(jobID, new AdapterError(error))
+          assertError({ expected: 500, actual: errorResp.statusCode }, errorResp, jobID)
+        }
+      })
+    })
+  })
+})

coinapi/test/adapter_test.js

@@ -27,6 +27,20 @@ describe('execute', () => {
         name: 'coin/market lowercase',
         testData: { id: jobID, data: { coin: 'eth', market: 'usd' } },
       },
+      {
+        name: 'BTC testnet difficulty',
+        testData: {
+          id: jobID,
+          data: { blockchain: 'BTC', network: 'testnet', endpoint: 'difficulty' },
+        },
+      },
+      {
+        name: 'BTC mainnet height',
+        testData: {
+          id: jobID,
+          data: { blockchain: 'BTC', endpoint: 'height' },
+        },
+      },
     ]
 
     requests.forEach((req) => {

composite/bitcoin-json-rpc/.eslintrc.js

@@ -0,0 +1,3 @@
+module.exports = {
+  ...require('../../.eslintrc.ts.js'),
+}

composite/bitcoin-json-rpc/README.md

@@ -0,0 +1,86 @@
+# Bitcoin JSON-RPC Blockchain info adapter for Chainlink
+
+- Takes optional connection to RPC endpoint (set via `RPC_URL` environment variable)
+
+## Input Params
+
+Returns blockchain info stats, by calling `"method": "getblockchainfo"`. It relies on `json-rpc` adapter.
+
+- `endpoint`: The parameter to query for. Default: "difficulty"
+
+## Output
+
+```json
+{
+  "jobRunID": "1",
+  "data": {
+    "chain": "main",
+    "blocks": 412022,
+    "headers": 665582,
+    "bestblockhash": "0000000000000000056482e60e14364c82903764eb88aef8fb0b1b60647334be",
+    "difficulty": 194254820283.444,
+    "mediantime": 1463406562,
+    "verificationprogress": 0.2162006436056612,
+    "initialblockdownload": true,
+    "chainwork": "0000000000000000000000000000000000000000001973393fcfc0215ecc9726",
+    "size_on_disk": 4758448869,
+    "pruned": true,
+    "pruneheight": 406538,
+    "automatic_pruning": true,
+    "prune_target_size": 5242880000,
+    "softforks": {
+      "bip34": {
+        "type": "buried",
+        "active": true,
+        "height": 227931
+      },
+      "bip66": {
+        "type": "buried",
+        "active": true,
+        "height": 363725
+      },
+      "bip65": {
+        "type": "buried",
+        "active": true,
+        "height": 388381
+      },
+      "csv": {
+        "type": "buried",
+        "active": false,
+        "height": 419328
+      },
+      "segwit": {
+        "type": "buried",
+        "active": false,
+        "height": 481824
+      }
+    },
+    "warnings": "",
+    "result": 665582
+  },
+  "result": 665582,
+  "statusCode": 200
+}
+```
+
+## Install
+
+Install dependencies
+
+```bash
+yarn
+```
+
+Set the `RPC_URL` environment variable to your client URL.
+
+## Testing
+
+Testing is dependent on the type of node you're connecting to. You can set a local environment variable `RPC_URL` to point to an RPC connection. Otherwise, the adapter will default to `"http://localhost:8545"`.
+
+RPC Address and Port Defaults:
+
+- BTC: (bitcoind) http://localhost:8332 (btcd) http://localhost:8334
+
+```bash
+yarn test
+```

composite/bitcoin-json-rpc/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@chainlink/bitcoin-json-rpc-adapter",
+  "version": "0.0.1",
+  "description": "",
+  "author": "Evangelos Barakos (evangelos@smartcontract.com)",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepublishOnly": "yarn build && yarn test:unit",
+    "setup": "yarn build",
+    "build": "tsc -b",
+    "lint": "eslint --ignore-path ../../.eslintignore . --ext .js,.jsx,.ts,.tsx",
+    "lint:fix": "eslint --ignore-path ../../.eslintignore . --ext .js,.jsx,.ts,.tsx --fix",
+    "test": "mocha --exit -r ts-node/register 'test/**/*.test.ts'",
+    "test:unit": "mocha --exit --grep @integration --invert -r ts-node/register 'test/**/*.test.ts'",
+    "test:integration": "mocha --exit --grep @integration -r ts-node/register 'test/**/*.test.ts'",    "server": "node -e 'require(\"./index.js\").server()'",
+    "server:dist": "node -e 'require(\"./dist/index.js\").server()'",
+    "start": "yarn server:dist"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.2.11",
+    "@types/mocha": "^7.0.2",
+    "@types/node": "^14.0.13",
+    "@typescript-eslint/eslint-plugin": "^3.9.0",
+    "@typescript-eslint/parser": "^3.9.0",
+    "ts-node": "^8.10.2",
+    "typescript": "^3.9.7"
+  },
+  "dependencies": {
+    "@chainlink/json-rpc-adapter": "^0.0.1"
+  }
+}

composite/bitcoin-json-rpc/src/adapter.ts

@@ -0,0 +1,38 @@
+import JSONRPC from '@chainlink/json-rpc-adapter'
+import { Config, ExecuteWithConfig, ExecuteFactory, AdapterRequest } from '@chainlink/types'
+import { Validator, Requester } from '@chainlink/external-adapter'
+import { DEFAULT_ENDPOINT, makeConfig } from './config'
+
+const inputParams = {
+  endpoint: false,
+}
+
+const convertEndpoint: { [key: string]: string } = {
+  height: 'headers',
+}
+
+// Export function to integrate with Chainlink node
+const execute: ExecuteWithConfig<Config> = async (request: AdapterRequest) => {
+  const validator = new Validator(request, inputParams)
+  if (validator.error) throw validator.error
+
+  const jobRunID = validator.validated.id
+  let endpoint = validator.validated.data.endpoint || DEFAULT_ENDPOINT
+
+  const response = await JSONRPC.execute({
+    ...request,
+    data: { ...request.data, method: 'getblockchaininfo' },
+  })
+
+  if (endpoint in convertEndpoint) endpoint = convertEndpoint[endpoint]
+  const result = Requester.validateResultNumber(response.data, ['result', endpoint])
+  return Requester.success(jobRunID, {
+    data: { ...response.data.result, result },
+    result,
+    status: 200,
+  })
+}
+
+export const makeExecute: ExecuteFactory<Config> = (config) => {
+  return async (request) => execute(request, config || makeConfig())
+}

composite/bitcoin-json-rpc/src/config.ts

@@ -0,0 +1,7 @@
+import { Requester } from '@chainlink/external-adapter'
+import { Config } from '@chainlink/types'
+
+export const DEFAULT_ENDPOINT = 'difficulty'
+
+// TODO: needs to setup config for underlying JSON-RPC adapter
+export const makeConfig = (prefix?: string): Config => Requester.getDefaultConfig(prefix)

composite/bitcoin-json-rpc/src/index.ts

@@ -0,0 +1,6 @@
+import { makeConfig } from './config'
+import { makeExecute } from './adapter'
+import { expose, util } from '@chainlink/ea-bootstrap'
+
+const NAME = 'BITCOIN-JSON-RPC'
+export = { NAME, makeExecute, makeConfig, ...expose(util.wrapExecute(makeExecute())) }