lightning 6.6.0 → 6.7.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Versions
 
+## 6.7.0
+
+- `getBlock`: add `height` to allow fetching a raw block at a specified height
+
 ## 6.6.0
 
 - `getBlock`: Add method to get a raw block from the chain

package/lnd_methods/onchain/get_block.js

@@ -6,8 +6,9 @@ const {isLnd} = require('./../../lnd_requests');
 const bufferAsHex = buffer => buffer.toString('hex');
 const errorNotFound = '-5: Block not found';
 const errorUnknownMethod = 'unknown service chainrpc.ChainKit';
-const hexAsBuffer = hex => Buffer.from(hex, 'hex').reverse();
+const hexAsReversedBuffer = hex => Buffer.from(hex, 'hex').reverse();
 const {isBuffer} = Buffer;
+const isNumber = n => !isNaN(n);
 const isHash = n => /^[0-9A-F]{64}$/i.test(n);
 const method = 'getBlock';
 const type = 'blocks';
@@ -21,7 +22,8 @@ const type = 'blocks';
   This method is not supported on LND 0.15.5 and below
 
   {
-    id: <Block Hash Hex String>
+    [height]: <Block Height Number>
+    [id]: <Block Hash Hex String>
     lnd: <Authenticated LND API Object>
   }
 
@@ -30,15 +32,23 @@ const type = 'blocks';
     block: <Raw Block Bytes Hex String>
   }
 */
-module.exports = ({id, lnd}, cbk) => {
+module.exports = ({height, id, lnd}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (!isHash(id)) {
+        if (height !== undefined && !isNumber(height)) {
+          return cbk([400, 'ExpectedNumericBlockHeightOfBlockToRetrieve']);
+        }
+
+        if (!!id && !isHash(id)) {
           return cbk([400, 'ExpectedIdentifyingBlockHashOfBlockToRetrieve']);
         }
 
+        if (height !== undefined && !!id) {
+          return cbk([400, 'ExpectedEitherHeightOrIdNotBoth']);
+        }
+
         if (!isLnd({lnd, method, type})) {
           return cbk([400, 'ExpectedAuthenticatedLndToRetrieveBlock']);
         }
@@ -46,9 +56,70 @@ module.exports = ({id, lnd}, cbk) => {
         return cbk();
       },
 
+      // Get the best block in the chain to find the default block hash
+      getTip: ['validate', ({}, cbk) => {
+        // Exit early when a specific block is requested
+        if (height !== undefined || !!id) {
+          return cbk();
+        }
+
+        return lnd[type].getBestBlock({}, (err, res) => {
+          if (!!err && err.details === errorUnknownMethod) {
+            return cbk([501, 'GetBestBlockMethodNotSupported']);
+          }
+
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorGettingBestBlock', {err}]);
+          }
+
+          if (!res) {
+            return cbk([503, 'ExpectedResponseForBestBlockRequest']);
+          }
+
+          if (!isBuffer(res.block_hash)) {
+            return cbk([503, 'ExpectedChainTipInfoInGetBestBlockResponse']);
+          }
+
+          return cbk(null, res.block_hash);
+        });
+      }],
+
+      // Get the hash of the block to fetch
+      getHash: ['getTip', ({getTip}, cbk) => {
+        // Exit early when the hash to get is specified
+        if (!!id) {
+          return cbk(null, hexAsReversedBuffer(id));
+        }
+
+        // Exit early when the hash comes from the chain tip
+        if (!!getTip) {
+          return cbk(null, getTip);
+        }
+
+        return lnd[type].getBlockHash({block_height: height}, (err, res) => {
+          if (!!err && err.details === errorUnknownMethod) {
+            return cbk([501, 'GetBlockHashMethodNotSupported']);
+          }
+
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorGettingBlockHash', {err}]);
+          }
+
+          if (!res) {
+            return cbk([503, 'ExpectedResponseForGetBlockHashRequest']);
+          }
+
+          if (!isBuffer(res.block_hash)) {
+            return cbk([503, 'ExpectedBlockHashInGetBlockHashResponse']);
+          }
+
+          return cbk(null, res.block_hash);
+        });
+      }],
+
       // Get the block
-      getBlock: ['validate', ({}, cbk) => {
-        return lnd[type][method]({block_hash: hexAsBuffer(id)}, (err, res) => {
+      getBlock: ['getHash', ({getHash}, cbk) => {
+        return lnd[type][method]({block_hash: getHash}, (err, res) => {
           if (!!err && err.details === errorNotFound) {
             return cbk([404, 'BlockNotFound']);
           }

package/package.json

@@ -10,7 +10,7 @@
     "@grpc/grpc-js": "1.8.0",
     "@grpc/proto-loader": "0.7.4",
     "@types/express": "4.17.15",
-    "@types/node": "18.11.15",
+    "@types/node": "18.11.16",
     "@types/request": "2.48.8",
     "@types/ws": "8.5.3",
     "async": "3.2.4",
@@ -59,5 +59,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "6.6.0"
+  "version": "6.7.0"
 }

package/test/lnd_methods/onchain/test_get_block.js

@@ -4,15 +4,129 @@ const {getBlock} = require('./../../../lnd_methods');
 
 const tests = [
   {
-    args: {},
-    description: 'An id is expected to get a block',
+    args: {height: 'invalid'},
+    description: 'A valid height is expected to get a block',
+    error: [400, 'ExpectedNumericBlockHeightOfBlockToRetrieve'],
+  },
+  {
+    args: {id: 'invalid'},
+    description: 'A valid id is expected to get a block',
     error: [400, 'ExpectedIdentifyingBlockHashOfBlockToRetrieve'],
   },
+  {
+    args: {height: 1, id: Buffer.alloc(32).toString('hex')},
+    description: 'Only a height or an id is required',
+    error: [400, 'ExpectedEitherHeightOrIdNotBoth'],
+  },
   {
     args: {id: Buffer.alloc(32).toString('hex')},
     description: 'An lnd object is required to get a block',
     error: [400, 'ExpectedAuthenticatedLndToRetrieveBlock'],
   },
+  {
+    args: {
+      lnd: {
+        blocks: {
+          getBestBlock: ({}, cbk) => cbk({
+            details: 'unknown service chainrpc.ChainKit',
+          }),
+          getBlock: ({}, cbk) => cbk('err'),
+        },
+      },
+    },
+    description: 'An unsupported error is returned',
+    error: [501, 'GetBestBlockMethodNotSupported'],
+  },
+  {
+    args: {
+      lnd: {
+        blocks: {
+          getBestBlock: ({}, cbk) => cbk('err'),
+          getBlock: ({}, cbk) => cbk('getBlockErr'),
+        },
+      },
+    },
+    description: 'An error is returned',
+    error: [503, 'UnexpectedErrorGettingBestBlock', {err: 'err'}],
+  },
+  {
+    args: {
+      lnd: {
+        blocks: {
+          getBestBlock: ({}, cbk) => cbk(),
+          getBlock: ({}, cbk) => cbk(),
+        },
+      },
+    },
+    description: 'An error is returned when there is no best block result',
+    error: [503, 'ExpectedResponseForBestBlockRequest'],
+  },
+  {
+    args: {
+      lnd: {
+        blocks: {
+          getBestBlock: ({}, cbk) => cbk(null, {}),
+          getBlock: ({}, cbk) => cbk(),
+        },
+      },
+    },
+    description: 'An error is returned when there is no result info',
+    error: [503, 'ExpectedChainTipInfoInGetBestBlockResponse'],
+  },
+  {
+    args: {
+      height: 1,
+      lnd: {
+        blocks: {
+          getBlock: ({}, cbk) => cbk(),
+          getBlockHash: ({}, cbk) => cbk({
+            details: 'unknown service chainrpc.ChainKit',
+          }),
+        },
+      },
+    },
+    description: 'An error is returned when get hash for height unsupported',
+    error: [501, 'GetBlockHashMethodNotSupported'],
+  },
+  {
+    args: {
+      height: 1,
+      lnd: {
+        blocks: {
+          getBlock: ({}, cbk) => cbk(),
+          getBlockHash: ({}, cbk) => cbk('err'),
+        },
+      },
+    },
+    description: 'An unexpected error for getting block hash is returned',
+    error: [503, 'UnexpectedErrorGettingBlockHash', {err: 'err'}],
+  },
+  {
+    args: {
+      height: 1,
+      lnd: {
+        blocks: {
+          getBlock: ({}, cbk) => cbk(),
+          getBlockHash: ({}, cbk) => cbk(),
+        },
+      },
+    },
+    description: 'A result is expected for getting a block hash',
+    error: [503, 'ExpectedResponseForGetBlockHashRequest'],
+  },
+  {
+    args: {
+      height: 1,
+      lnd: {
+        blocks: {
+          getBlock: ({}, cbk) => cbk(),
+          getBlockHash: ({}, cbk) => cbk(null, {}),
+        },
+      },
+    },
+    description: 'A result hash is expected for getting a block hash',
+    error: [503, 'ExpectedBlockHashInGetBlockHashResponse'],
+  },
   {
     args: {
       id: Buffer.alloc(32).toString('hex'),
@@ -63,6 +177,31 @@ const tests = [
     description: 'A resulting block is expected',
     error: [503, 'ExpectedRawBlockInChainBlockResponse'],
   },
+  {
+    args: {
+      lnd: {
+        blocks: {
+          getBestBlock: ({}, cbk) => cbk(null, {block_hash: Buffer.alloc(1)}),
+          getBlock: ({}, cbk) => cbk(null, {raw_block: Buffer.alloc(1)}),
+        },
+      },
+    },
+    description: 'The chain tip block is returned',
+    expected: {block: '00'},
+  },
+  {
+    args: {
+      height: 1,
+      lnd: {
+        blocks: {
+          getBlock: ({}, cbk) => cbk(null, {raw_block: Buffer.alloc(1)}),
+          getBlockHash: ({}, cbk) => cbk(null, {block_hash: Buffer.alloc(1)}),
+        },
+      },
+    },
+    description: 'A block at a height is returned',
+    expected: {block: '00'},
+  },
   {
     args: {
       id: Buffer.alloc(32).toString('hex'),