lightning/test/lnd_methods/macaroon/test_grant_access.js

Lightning Network client library

const {rejects} = require('node:assert').strict;
const {strictEqual} = require('node:assert').strict;
const test = require('node:test');

const {grantAccess} = require('./../../../');

const tests = [
  {
    args: {},
    description: 'An access privilege is required to grant access',
    error: [400, 'ExpectedAccessPrivilegeToGrantAccessCredential'],
  },
  {
    args: {is_ok_to_create_chain_addresses: true},
    description: 'LND is required to grant access',
    error: [400, 'ExpectedLndToGrantAccessCredential'],
  },
  {
    args: {
      is_ok_to_create_chain_addresses: true,
      lnd: {default: {bakeMacaroon: ({}, cbk) => cbk('err')}},
    },
    description: 'Errors are passed back',
    error: [503, 'UnexpectedErrorFromBakeMacaroon', {err: 'err'}],
  },
  {
    args: {
      is_ok_to_create_chain_addresses: true,
      lnd: {default: {bakeMacaroon: ({}, cbk) => cbk('err')}},
    },
    description: 'Errors from the RPC are relayed',
    error: [503, 'UnexpectedErrorFromBakeMacaroon', {err: 'err'}],
  },
  {
    args: {
      is_ok_to_create_chain_addresses: true,
      lnd: {
        default: {
          bakeMacaroon: ({}, cbk) => cbk({
            details: 'unknown service lnrpc.Lightning',
          }),
        },
      },
    },
    description: 'Not supported is returned',
    error: [501, 'GrantAccessMethodNotSupported'],
  },
  {
    args: {
      is_ok_to_create_chain_addresses: true,
      lnd: {
        default: {
          bakeMacaroon: ({}, cbk) => cbk({details: 'permission denied'}),
        },
      },
    },
    description: 'Access denied is returned',
    error: [403, 'PermissionDeniedToBakeMacaroon'],
  },
  {
    args: {
      is_ok_to_create_chain_addresses: true,
      lnd: {default: {bakeMacaroon: ({}, cbk) => cbk()}},
    },
    description: 'A response is expected',
    error: [503, 'ExpectedResponseFromBakeMacaroonRequest'],
  },
  {
    args: {
      is_ok_to_create_chain_addresses: true,
      lnd: {default: {bakeMacaroon: ({}, cbk) => cbk(null, {macaroon: 'fo'})}},
    },
    description: 'A hex macaroon is expected',
    error: [503, 'ExpectedHexSerializedMacaroonCredentials'],
  },
  {
    args: {
      lnd: {default: {bakeMacaroon: ({}, cbk) => cbk(null, {macaroon: '00'})}},
      methods: ['unknownMethod'],
    },
    description: 'Unknown method is not supported',
    error: [400, 'ExpectedKnownMethodNameToDeriveMacaroonUris'],
  },
  {
    args: {
      is_ok_to_create_chain_addresses: true,
      lnd: {
        default: {
          bakeMacaroon: (args, cbk) => {
            if (!args.permissions || args.permissions.length !== 1) {
              return cbk('ExpectedPermissions');
            }

            const [{action, entity}] = args.permissions;

            if (action !== 'write' || entity !== 'address') {
              return cbk('ExpectedPermissionEntity');
            }

            return cbk(null, {macaroon: '00'});
          },
        },
      },
    },
    description: 'Macaroon returned',
    expected: {macaroon: 'AA=='},
  },
  {
    args: {
      lnd: {default: {bakeMacaroon: ({}, cbk) => cbk(null, {macaroon: '00'})}},
      methods: ['grantAccess'],
    },
    description: 'Macaroon returned',
    expected: {macaroon: 'AA=='},
  },
];

tests.forEach(({args, description, error, expected}) => {
  return test(description, async () => {
    if (!!error) {
      await rejects(() => grantAccess(args), error, 'Got expected error');
    } else {
      const {macaroon} = await grantAccess(args);

      strictEqual(macaroon, expected.macaroon, 'Got expected macaroon');
    }

    return;
  });
});