tapass 0.0.0-stage → 0.2.0

package/src/tapd_methods/daemon/index.ts

@@ -0,0 +1,7 @@
+export {default as createTapdMacaroon} from './create_tapd_macaroon.js';
+export type {CreateTapdMacaroonArgs} from './create_tapd_macaroon.js';
+export type {CreateTapdMacaroonResult} from './create_tapd_macaroon.js';
+export {default as setTapdDebugLevel} from './set_tapd_debug_level.js';
+export type {SetTapdDebugLevelArgs} from './set_tapd_debug_level.js';
+export {default as stopTapd} from './stop_tapd.js';
+export type {StopTapdArgs} from './stop_tapd.js';

package/src/tapd_methods/daemon/set_tapd_debug_level.ts

@@ -0,0 +1,90 @@
+import {auto as asyncAuto} from 'async';
+import {returnResult} from 'asyncjs-util';
+
+import {isConnectionFailure} from '../../tapd_requests/index.js';
+import {isPermissionDenied} from '../../tapd_requests/index.js';
+import {isTapd} from '../../tapd_requests/index.js';
+import type {AuthenticatedTapdArgs} from '../../typescript/index.js';
+import type {TapdCallback} from '../../typescript/index.js';
+import type {TapdError} from '../../typescript/index.js';
+import type {TapdMethod} from '../../typescript/index.js';
+
+const isLevel = (n: unknown) => typeof n === 'string' && /^[\w=,.-]+$/.test(n);
+const method = 'debugLevel';
+const type = 'default';
+
+export type SetTapdDebugLevelArgs = AuthenticatedTapdArgs<{
+  /** Log Level Specification String */
+  level: string;
+}>;
+
+type Tasks = {
+  set: undefined;
+  validate: undefined;
+};
+
+/** Set the log level of tapd
+
+  Use a level for all subsystems, for example `debug`, or a level for each
+  subsystem, for example `TADB=trace,FRTR=info`
+
+  Requires `daemon:write` permission
+
+  {
+    level: <Log Level Specification String>
+    tapd: <Authenticated tapd API Object>
+  }
+
+  @returns via cbk or Promise
+*/
+const setTapdDebugLevel: TapdMethod<SetTapdDebugLevelArgs, void> = (
+  args: SetTapdDebugLevelArgs,
+  cbk?: TapdCallback<void>,
+) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto<Tasks, TapdError>(
+      {
+        // Check arguments
+        validate: cbk => {
+          if (!isLevel(args.level)) {
+            return cbk([400, 'ExpectedLogLevelToSetTapdDebugLevel']);
+          }
+
+          if (!isTapd({method, type, tapd: args.tapd})) {
+            return cbk([400, 'ExpectedAuthenticatedTapdToSetTapdDebugLevel']);
+          }
+
+          return cbk();
+        },
+
+        // Set the log level
+        set: [
+          'validate',
+          ({}, cbk) => {
+            const request = {level_spec: args.level, show: false};
+
+            return args.tapd[type][method](request, (err: any) => {
+              if (isConnectionFailure({err})) {
+                return cbk([503, 'FailedToConnectToTapdToSetTapdDebugLevel']);
+              }
+
+              if (isPermissionDenied({err})) {
+                return cbk([403, 'PermissionDeniedToSetTapdDebugLevel']);
+              }
+
+              // tapd returns the log level parse errors as unknown errors
+              if (!!err) {
+                return cbk([400, 'FailedToSetTapdDebugLevel', {err}]);
+              }
+
+              return cbk();
+            });
+          },
+        ],
+      },
+      returnResult({reject, resolve}, cbk),
+    );
+  });
+};
+
+export default setTapdDebugLevel;

package/src/tapd_methods/daemon/stop_tapd.ts

@@ -0,0 +1,75 @@
+import {auto as asyncAuto} from 'async';
+import {returnResult} from 'asyncjs-util';
+
+import {isConnectionFailure} from '../../tapd_requests/index.js';
+import {isPermissionDenied} from '../../tapd_requests/index.js';
+import {isTapd} from '../../tapd_requests/index.js';
+import type {AuthenticatedTapdArgs} from '../../typescript/index.js';
+import type {TapdCallback} from '../../typescript/index.js';
+import type {TapdError} from '../../typescript/index.js';
+import type {TapdMethod} from '../../typescript/index.js';
+
+const method = 'stopDaemon';
+const type = 'default';
+
+export type StopTapdArgs = AuthenticatedTapdArgs;
+
+type Tasks = {
+  stop: undefined;
+  validate: undefined;
+};
+
+/** Stop tapd
+
+  Requires `daemon:write` permission
+
+  {
+    tapd: <Authenticated tapd API Object>
+  }
+
+  @returns via cbk or Promise
+*/
+const stopTapd: TapdMethod<StopTapdArgs, void> = (
+  args: StopTapdArgs,
+  cbk?: TapdCallback<void>,
+) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto<Tasks, TapdError>(
+      {
+        // Check arguments
+        validate: cbk => {
+          if (!isTapd({method, type, tapd: args.tapd})) {
+            return cbk([400, 'ExpectedAuthenticatedTapdToStopTapd']);
+          }
+
+          return cbk();
+        },
+
+        // Stop tapd
+        stop: [
+          'validate',
+          ({}, cbk) => {
+            return args.tapd[type][method]({}, (err: any) => {
+              if (isConnectionFailure({err})) {
+                return cbk([503, 'FailedToConnectToTapdToStopTapd']);
+              }
+
+              if (isPermissionDenied({err})) {
+                return cbk([403, 'PermissionDeniedToStopTapd']);
+              }
+
+              if (!!err) {
+                return cbk([503, 'UnexpectedErrorStoppingTapd', {err}]);
+              }
+
+              return cbk();
+            });
+          },
+        ],
+      },
+      returnResult({reject, resolve}, cbk),
+    );
+  });
+};
+
+export default stopTapd;

package/src/tapd_methods/index.ts

@@ -0,0 +1,9 @@
+export * from './address/index.js';
+export * from './assets/index.js';
+export * from './channels/index.js';
+export * from './daemon/index.js';
+export * from './info/index.js';
+export * from './mint/index.js';
+export * from './proofs/index.js';
+export * from './rfq/index.js';
+export * from './send/index.js';

package/src/tapd_methods/info/get_tapd_info.ts

@@ -0,0 +1,129 @@
+import {auto as asyncAuto} from 'async';
+import {returnResult} from 'asyncjs-util';
+
+import {isConnectionFailure} from '../../tapd_requests/index.js';
+import {isPermissionDenied} from '../../tapd_requests/index.js';
+import {isTapd} from '../../tapd_requests/index.js';
+import type {AuthenticatedTapdArgs} from '../../typescript/index.js';
+import type {TapdCallback} from '../../typescript/index.js';
+import type {TapdError} from '../../typescript/index.js';
+import type {TapdMethod} from '../../typescript/index.js';
+
+const isHash = (n: unknown) =>
+  typeof n === 'string' && /^[0-9a-f]{64}$/i.test(n);
+const isPublicKey = (n: unknown) =>
+  typeof n === 'string' && /^0[23][0-9a-f]{64}$/i.test(n);
+const method = 'getInfo';
+const type = 'default';
+
+export type GetTapdInfoArgs = AuthenticatedTapdArgs;
+
+export type GetTapdInfoResult = {
+  /** lnd Node Alias */
+  alias: string;
+  /** Best Chain Block Hash Hex */
+  current_block_hash: string;
+  /** Best Chain Block Height */
+  current_block_height: number;
+  /** tapd Is Synced To Chain */
+  is_synced_to_chain: boolean;
+  /** lnd Version */
+  lnd_version: string;
+  /** Network Name */
+  network: string;
+  /** lnd Identity Public Key Hex */
+  public_key: string;
+  /** tapd Version */
+  version: string;
+};
+
+type Tasks = {
+  getInfo: GetTapdInfoResult;
+  validate: undefined;
+};
+
+/** Get information about tapd and its lnd node
+
+  Requires `daemon:read` permission
+
+  {
+    tapd: <Authenticated tapd API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    alias: <lnd Node Alias String>
+    current_block_hash: <Best Chain Block Hash Hex String>
+    current_block_height: <Best Chain Block Height Number>
+    is_synced_to_chain: <tapd Is Synced To Chain Bool>
+    lnd_version: <lnd Version String>
+    network: <Network Name String>
+    public_key: <lnd Identity Public Key Hex String>
+    version: <tapd Version String>
+  }
+*/
+const getTapdInfo: TapdMethod<GetTapdInfoArgs, GetTapdInfoResult> = (
+  args: GetTapdInfoArgs,
+  cbk?: TapdCallback<GetTapdInfoResult>,
+) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto<Tasks, TapdError>(
+      {
+        // Check arguments
+        validate: cbk => {
+          if (!isTapd({method, type, tapd: args.tapd})) {
+            return cbk([400, 'ExpectedAuthenticatedTapdToGetTapdInfo']);
+          }
+
+          return cbk();
+        },
+
+        // Get the info
+        getInfo: [
+          'validate',
+          ({}, cbk) => {
+            return args.tapd[type][method]({}, (err: any, res: any) => {
+              if (isConnectionFailure({err})) {
+                return cbk([503, 'FailedToConnectToTapdToGetTapdInfo']);
+              }
+
+              if (isPermissionDenied({err})) {
+                return cbk([403, 'PermissionDeniedToGetTapdInfo']);
+              }
+
+              if (!!err) {
+                return cbk([503, 'UnexpectedErrorGettingTapdInfo', {err}]);
+              }
+
+              if (!res || !res.version) {
+                return cbk([503, 'ExpectedVersionInTapdInfoResponse']);
+              }
+
+              if (!isHash(res.block_hash)) {
+                return cbk([503, 'ExpectedBlockHashInTapdInfoResponse']);
+              }
+
+              if (!isPublicKey(res.lnd_identity_pubkey)) {
+                return cbk([503, 'ExpectedLndPublicKeyInTapdInfoResponse']);
+              }
+
+              return cbk(null, {
+                alias: res.node_alias,
+                current_block_hash: res.block_hash,
+                current_block_height: res.block_height,
+                is_synced_to_chain: res.sync_to_chain,
+                lnd_version: res.lnd_version,
+                network: res.network,
+                public_key: res.lnd_identity_pubkey,
+                version: res.version,
+              });
+            });
+          },
+        ],
+      },
+      returnResult({reject, resolve, of: 'getInfo'}, cbk),
+    );
+  });
+};
+
+export default getTapdInfo;

package/src/tapd_methods/info/index.ts

@@ -0,0 +1,3 @@
+export {default as getTapdInfo} from './get_tapd_info.js';
+export type {GetTapdInfoArgs} from './get_tapd_info.js';
+export type {GetTapdInfoResult} from './get_tapd_info.js';