astra-lightning 1.0.0

package/lnd_responses/failure_from_payment.d.ts

@@ -0,0 +1,63 @@
+import {FailureReason} from '../typescript';
+
+export type FailureFromPaymentArgs = {
+  payment_hash: string;
+  failure_reason: FailureReason;
+};
+
+export type FailureFromPaymentResult = {
+  /** Payment Hash Hex String */
+  id: string;
+  /** Payment Failed Due to Insufficient Balance Bool */
+  is_insufficient_balance: boolean;
+  /** Payment Failed Due to Invalid Details Rejection Bool */
+  is_invalid_payment: boolean;
+  /** Failure Due To Pathfinding Timeout Failure Bool */
+  is_pathfinding_timeout: boolean;
+  /** Failure Due to No Route To Destination Found Bool */
+  is_route_not_found: boolean;
+};
+
+export function failureFromPayment(payment: {
+  payment_hash: string,
+  failure_reason: 'FAILURE_REASON_INSUFFICIENT_BALANCE';
+}): {
+  id: string,
+  is_insufficient_balance: true;
+  is_invalid_payment: false;
+  is_pathfinding_timeout: false;
+  is_route_not_found: false;
+};
+export function failureFromPayment(payment: {
+  payment_hash: string,
+  failure_reason: 'FAILURE_REASON_INCORRECT_PAYMENT_DETAILS';
+}): {
+  id: string,
+  is_insufficient_balance: false;
+  is_invalid_payment: true;
+  is_pathfinding_timeout: false;
+  is_route_not_found: false;
+};
+export function failureFromPayment(payment: {
+  payment_hash: string,
+  failure_reason: 'FAILURE_REASON_TIMEOUT';
+}): {
+  id: string,
+  is_insufficient_balance: false;
+  is_invalid_payment: false;
+  is_pathfinding_timeout: true;
+  is_route_not_found: false;
+};
+export function failureFromPayment(payment: {
+  payment_hash: string,
+  failure_reason: 'FAILURE_REASON_NO_ROUTE';
+}): {
+  id: string,
+  is_insufficient_balance: false;
+  is_invalid_payment: false;
+  is_pathfinding_timeout: false;
+  is_route_not_found: true;
+};
+export function failureFromPayment(
+  payment: FailureFromPaymentArgs
+): FailureFromPaymentResult;

package/lnd_responses/failure_from_payment.js

@@ -0,0 +1,40 @@
+const {failureReason} = require('./constants');
+
+const is256Hex = n => !!n && /^[0-9A-F]{64}$/i.test(n);
+
+/** Derive failure status from payment
+
+  {
+    failure_reason: <Payment Failure Reason String>
+    payment_hash: <Payment SHA256 Hash Hex String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    id: <Payment Hash Hex String>
+    is_canceled: <Payment Was Canceled Bool>
+    is_insufficient_balance: <Payment Failed Due to Insufficient Balance Bool>
+    is_invalid_payment: <Payment Failed Due to Invalid Details Rejection Bool>
+    is_pathfinding_timeout: <Failure Due To Pathfinding Timeout Failure Bool>
+    is_route_not_found: <Failure Due to No Route To Destination Found Bool>
+  }
+*/
+module.exports = payment => {
+  const state = payment.failure_reason;
+
+  if (!is256Hex(payment.payment_hash)) {
+    throw new Error('ExpectedPaymentHashForPaymentAsFailedPayment');
+  }
+
+  return {
+    id: payment.payment_hash,
+    is_canceled: state === failureReason.canceled,
+    is_insufficient_balance: state === failureReason.insufficient_balance,
+    is_invalid_payment: state === failureReason.invalid_payment,
+    is_pathfinding_timeout: state === failureReason.pathfinding_timeout_failed,
+    is_route_not_found: state === failureReason.pathfinding_routes_failed,
+  };
+};

package/lnd_responses/forward_from_htlc_event.js

@@ -0,0 +1,218 @@
+const { chanFormat } = require("bolt07");
+
+const { htlcTypes } = require("./constants");
+const { safeTokens } = require("../bolt00");
+
+const bufferAsHex = (buffer) => buffer.toString("hex");
+const nsPerMs = BigInt(1e6);
+
+/** Get RPC HTLC Event as a forward event
+
+  {
+    event_type: <Event Type String>
+    [forward_event]: {
+      info: {
+        incoming_amt_msat: <Incoming Channel HTLC Millitokens String>
+        incoming_timelock: <Incoming Channel CLTV Block Height Number>
+        outgoing_amt_msat: <Outgoing Channel HTLC Millitokens String>
+        outgoing_timelock: <Outgoing Channel CLTV Block Height Number>
+      }
+    }
+    [forward_fail_event]: <Forward Failure Event Object>
+    incoming_channel_id: <Inbound Channel Numeric Id String>
+    incoming_htlc_id: <Inbound Channel Historic Index Number>
+    [link_fail_event]: {
+      failure_detail: <Failure Code String>
+      failure_string: <Failure Description String>
+      info: {
+        incoming_amt_msat: <Incoming Channel HTLC Millitokens String>
+        incoming_timelock: <Incoming Channel CLTV Block Height Number>
+        outgoing_amt_msat: <Outgoing Channel HTLC Millitokens String>
+        outgoing_timelock: <Outgoing Channel CLTV Block Height Number>
+      }
+      wire_failure: <Wire Code String>
+    }
+    outgoing_channel_id: <Outbound Channel Numeric Id String>
+    outgoing_htlc_id: <Outbound Channel Historic Index Number>
+    [settle_event]: {
+      preimage: <HTLC Preimage Buffer Object>
+    }
+    timestamp_ns: <Timestamp Nanoseconds String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    at: <Forward Update At ISO 8601 Date String>
+    [cltv_delta]: <CLTV Delta Number>
+    [external_failure]: <Public Failure Reason String>
+    [fee]: <Fee Tokens Charged Number>
+    [fee_mtokens]: <Fee Millitokens Charged String>
+    [in_channel]: <Inbound Standard Format Channel Id String>
+    [in_payment]: <Inbound Channel Payment Id Number>
+    [internal_failure]: <Private Failure Reason String>
+    is_confirmed: <Forward Is Confirmed Bool>
+    is_failed: <Forward Is Failed Bool>
+    is_receive: <Is Receive Bool>
+    is_send: <Is Send Bool>
+    [mtokens]: <Sending Millitokens String>
+    [out_channel]: <Outgoing Standard Format Channel Id String>
+    [out_payment]: <Outgoing Channel Payment Id Number>
+    [secret]: <Settled Preimage Hex String>
+    [timeout]: <Forward Timeout at Height Number>
+    [tokens]: <Sending Tokens Number>
+  }
+*/
+module.exports = (htlc) => {
+  if (!htlc.event_type) {
+    throw new Error("ExpectedHtlcEventTypeToDeriveForwardFromHtlcEvent");
+  }
+
+  if (!!htlc.forward_event) {
+    if (!htlc.forward_event.info) {
+      throw new Error("ExpectedHtlcInfoInForwardEvent");
+    }
+
+    if (!htlc.forward_event.info.incoming_amt_msat) {
+      throw new Error("ExpectedForwardEventIncomingAmountMsatToDeriveForward");
+    }
+
+    if (htlc.forward_event.info.incoming_timelock === undefined) {
+      throw new Error("ExpectedForwardEventIncomingTimelockToDeriveForward");
+    }
+
+    if (!htlc.forward_event.info.outgoing_amt_msat) {
+      throw new Error("ExpectedForwardEventOutgoingAmountMsatToDeriveForward");
+    }
+
+    if (htlc.forward_event.info.outgoing_timelock === undefined) {
+      throw new Error("ExpectedForwardEventOutgoingTimelockToDeriveForward");
+    }
+  }
+
+  if (!htlc.incoming_channel_id) {
+    throw new Error("ExpectedIncomingChannelIdToDeriveForward");
+  }
+
+  if (!htlc.incoming_htlc_id) {
+    throw new Error("ExpectedIncomingHtlcIdToDeriveForward");
+  }
+
+  if (!!htlc.link_fail_event) {
+    if (!htlc.link_fail_event.failure_detail) {
+      throw new Error("ExpectedLinkFailureDetailInLinkFailureEvent");
+    }
+
+    if (!htlc.link_fail_event.failure_string) {
+      throw new Error("ExpectedLinkFailureStringInLinkFailureEvent");
+    }
+
+    if (!htlc.link_fail_event.info) {
+      throw new Error("ExpectedHtlcInfoInLinkFailEvent");
+    }
+
+    if (!htlc.link_fail_event.info.incoming_amt_msat) {
+      throw new Error("ExpectedLinkFailEventIncomingMsatToDeriveForward");
+    }
+
+    if (htlc.link_fail_event.info.incoming_timelock === undefined) {
+      throw new Error("ExpectedLinkFailEventIncomingTimelockToDeriveForward");
+    }
+
+    if (!htlc.link_fail_event.info.outgoing_amt_msat) {
+      throw new Error("ExpectedLinkFailEventOutgoingMsatToDeriveForward");
+    }
+
+    if (htlc.link_fail_event.info.outgoing_timelock === undefined) {
+      throw new Error("ExpectedForwardEventOutgoingTimelockToDeriveForward");
+    }
+  }
+
+  if (!htlc.outgoing_channel_id) {
+    throw new Error("ExpectedOutgoingChannelIdToDeriveForward");
+  }
+
+  if (!htlc.outgoing_htlc_id) {
+    throw new Error("ExpectedOutgoingHtlcIdToDeriveForward");
+  }
+
+  if (!!htlc.settle_event && !Buffer.isBuffer(htlc.settle_event.preimage)) {
+    throw new Error("ExpectedHtlcPreimageInForwardedSettleEvent");
+  }
+
+  if (!htlc.timestamp_ns) {
+    throw new Error("ExpectedHtlcTimestampToDeriveForward");
+  }
+
+  const createdAt = new Date(Number(BigInt(htlc.timestamp_ns) / nsPerMs));
+  const incoming = chanFormat({ number: htlc.incoming_channel_id });
+  const incomingId = Number(htlc.incoming_htlc_id);
+  const isFailure = !!htlc.forward_fail_event || !!htlc.link_fail_event;
+  const isForward = htlc.event_type === htlcTypes.forward;
+  const isReceive = htlc.event_type === htlcTypes.receive;
+  const isSend = htlc.event_type === htlcTypes.send;
+  const outgoing = chanFormat({ number: htlc.outgoing_channel_id });
+  const outgoingId = Number(htlc.outgoing_htlc_id);
+  const settleEvent = htlc.settle_event || { preimage: Buffer.alloc(Number()) };
+
+  // Exit early when there is no extended info, for failed forwards and settles
+  if (!!htlc.forward_fail_event || !!htlc.settle_event) {
+    return {
+      at: createdAt.toISOString(),
+      cltv_delta: undefined,
+      external_failure: undefined,
+      fee: undefined,
+      fee_mtokens: undefined,
+      in_channel: !!isSend ? undefined : incoming.channel,
+      in_payment: !!isSend ? undefined : incomingId,
+      internal_failure: undefined,
+      is_confirmed: !!htlc.settle_event,
+      is_failed: isFailure,
+      is_receive: isReceive,
+      is_send: isSend,
+      mtokens: undefined,
+      out_channel: !!isReceive ? undefined : outgoing.channel,
+      out_payment: !!isReceive ? undefined : outgoingId,
+      secret: bufferAsHex(settleEvent.preimage) || undefined,
+      timeout: undefined,
+      tokens: undefined,
+    };
+  }
+
+  if (!htlc.forward_event && !htlc.link_fail_event) {
+    throw new Error("ExpectedForwardEventOrLinkFailEventInHtlcEvent");
+  }
+
+  const { info } = htlc.forward_event || htlc.link_fail_event;
+
+  const outgoingAmount = BigInt(info.outgoing_amt_msat);
+  const outgoingCltvHeight = Number(info.outgoing_timelock);
+
+  const cltvDelta = Number(info.incoming_timelock) - outgoingCltvHeight;
+  const feeMtok = (BigInt(info.incoming_amt_msat) - outgoingAmount).toString();
+
+  const { tokens } = safeTokens({ mtokens: info.outgoing_amt_msat });
+
+  return {
+    at: createdAt.toISOString(),
+    cltv_delta: !isForward ? undefined : cltvDelta,
+    external_failure: (htlc.link_fail_event || {}).wire_failure,
+    fee: !isForward ? undefined : safeTokens({ mtokens: feeMtok }).tokens,
+    fee_mtokens: !isForward ? undefined : feeMtok,
+    in_channel: !!isSend ? undefined : incoming.channel,
+    in_payment: !!isSend ? undefined : incomingId,
+    internal_failure: (htlc.link_fail_event || {}).failure_detail,
+    is_confirmed: false,
+    is_failed: !!htlc.link_fail_event,
+    is_receive: isReceive,
+    is_send: isSend,
+    mtokens: !!isReceive ? undefined : info.outgoing_amt_msat,
+    out_channel: !!isReceive ? undefined : outgoing.channel,
+    out_payment: !!isReceive ? undefined : outgoingId,
+    secret: bufferAsHex(settleEvent.preimage) || undefined,
+    timeout: !!isReceive ? undefined : outgoingCltvHeight,
+    tokens: !!isReceive ? undefined : tokens,
+  };
+};

package/lnd_responses/htlc_as_payment.js

@@ -0,0 +1,117 @@
+const BN = require('bn.js');
+const {chanFormat} = require('bolt07');
+
+const {htlcStates} = require('./constants');
+
+const dateFrom = seconds => new Date(1e3 * seconds).toISOString();
+const endian = 'le';
+const {keys} = Object;
+const mtokensPerToken = BigInt(1e3);
+
+/** Convert raw API HTLC response to payment attributes
+
+  {
+    accept_height: <HTLC Held Since Height Number>
+    accept_time: <HTLC Held Since Epoch Time Number String>
+    amt_msat: <HTLC Amount Millitokens String>
+    chan_id: <Numeric Channel Id String>
+    custom_records: {
+      <UInt64 String>: <Record Data Buffer>
+    }
+    expiry_height: <HTLC CLTV Expiration Height Number>
+    htlc_index: <Channel HTLC Index Number String>
+    mpp_total_amt_msat: <Total Payment Millitokens String>
+    resolve_time: <HTLC Removed At Epoch Time Number String>
+    state: <HTLC Lifecycle State String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    [canceled_at]: <Payment Canceled At ISO 8601 Date String>
+    [confirmed_at]: <Payment Settled At ISO 8601 Date String>
+    created_at: <Payment Held Since ISO 860 Date String>
+    created_height: <Payment Held Since Block Height Number>
+    in_channel: <Incoming Payment Through Channel Id String>
+    is_canceled: <Payment is Canceled Bool>
+    is_confirmed: <Payment is Confirmed Bool>
+    is_held: <Payment is Held Bool>
+    messages: [{
+      type: <Message Type Number String>
+      value: <Raw Value Hex String>
+    }]
+    mtokens: <Incoming Payment Millitokens String>
+    [pending_index]: <Pending Payment Channel HTLC Index Number>
+    timeout: <HTLC CLTV Timeout Height Number>
+    tokens: <Payment Tokens Number>
+    [total_mtokens]: <Total Millitokens String>
+  }
+*/
+module.exports = args => {
+  if (!args.accept_height) {
+    throw new Error('ExpectedAcceptHeightInResponseHtlc');
+  }
+
+  if (!args.accept_time) {
+    throw new Error('ExpectedAcceptTimeInResponseHtlc');
+  }
+
+  if (!args.amt_msat) {
+    throw new Error('ExpectedPaymentAmountInResponseHtlc');
+  }
+
+  if (!args.chan_id) {
+    throw new Error('ExpectedChannelIdInResponseHtlc');
+  }
+
+  if (!args.custom_records) {
+    throw new Error('ExpectedCustomRecordsInResponseHtlc');
+  }
+
+  if (!args.expiry_height) {
+    throw new Error('ExpectedHtlcExpiryHeightInResponseHtlc');
+  }
+
+  if (!args.htlc_index) {
+    throw new Error('ExpectedHtlcIndexInResponseHtlc');
+  }
+
+  if (args.resolve_time === undefined) {
+    throw new Error('ExpectedResolveTimeInResponseHtlc');
+  }
+
+  if (!args.state) {
+    throw new Error('ExpectedHtlcStateInResponseHtlc');
+  }
+
+  const isAccepted = args.state === htlcStates.accepted;
+  const isCanceled = args.state === htlcStates.canceled;
+  const isReceived = args.state === htlcStates.received;
+  const totalMtokens = args.mpp_total_amt_msat;
+
+  return {
+    canceled_at: !isCanceled ? undefined : dateFrom(args.resolve_time),
+    confirmed_at: !isReceived ? undefined : dateFrom(args.resolve_time),
+    created_at: dateFrom(args.accept_time),
+    created_height: args.accept_height,
+    in_channel: chanFormat({number: args.chan_id}).channel,
+    is_canceled: isCanceled,
+    is_confirmed: isReceived,
+    is_held: isAccepted,
+    messages: keys(args.custom_records).map(type => {
+      const rawType = Buffer.from(type, 'ascii').reverse();
+
+      return {
+        type: new BN(rawType).toString(),
+        value: args.custom_records[type].toString('hex'),
+      };
+    }),
+    mtokens: args.amt_msat,
+    pending_index: isAccepted ? Number(args.htlc_index) : undefined,
+    timeout: args.expiry_height,
+    tokens: Number(BigInt(args.amt_msat) / mtokensPerToken),
+    total_mtokens: totalMtokens === '0' ? undefined : totalMtokens,
+  };
+};

package/lnd_responses/index.d.ts

@@ -0,0 +1,2 @@
+export * from './confirmed_from_payment';
+export * from './failure_from_payment';

package/lnd_responses/index.js

@@ -0,0 +1,91 @@
+const backupsFromSnapshot = require('./backups_from_snapshot');
+const channelAcceptAsOpenRequest = require('./channel_accept_as_open_request');
+const channelEdgeAsChannel = require('./channel_edge_as_channel');
+const confirmedFromPayment = require('./confirmed_from_payment');
+const confirmedFromPaymentStatus = require('./confirmed_from_payment_status');
+const failureFromPayment = require('./failure_from_payment');
+const forwardFromHtlcEvent = require('./forward_from_htlc_event');
+const htlcAsPayment = require('./htlc_as_payment');
+const infoAsWalletInfo = require('./info_as_wallet_info');
+const nodeInfoAsNode = require('./node_info_as_node');
+const paymentFailure = require('./payment_failure');
+const paymentRequestDetails = require('./payment_request_details');
+const pendingAsPendingChannels = require('./pending_as_pending_channels');
+const pendingFromPayment = require('./pending_from_payment');
+const policyFromChannelUpdate = require('./policy_from_channel_update');
+const routesFromQueryRoutes = require('./routes_from_query_routes');
+const routingFailureFromHtlc = require('./routing_failure_from_htlc');
+const rpcAddressesAsAddresses = require('./rpc_addresses_as_addresses');
+const rpcAttemptHtlcAsAttempt = require('./rpc_attempt_htlc_as_attempt');
+const rpcChannelAsChannel = require('./rpc_channel_as_channel');
+const rpcChannelClosedAsClosed = require('./rpc_channel_closed_as_closed');
+const rpcChannelUpdateAsUpdate = require('./rpc_channel_update_as_update');
+const rpcClosedChannelAsClosed = require('./rpc_closed_channel_as_closed');
+const rpcConfAsConfirmation = require('./rpc_conf_as_confirmation');
+const rpcFailedPolicyAsFail = require('./rpc_failed_policy_as_fail');
+const rpcFeesAsChannelFees = require('./rpc_fees_as_channel_fees');
+const rpcForwardAsForward = require('./rpc_forward_as_forward');
+const rpcForwardAsForwardRequest = require('./rpc_forward_as_forward_request');
+const rpcGroupSessionAsSession = require('./rpc_group_session_as_session');
+const rpcHopAsHop = require('./rpc_hop_as_hop');
+const rpcInvoiceAsInvoice = require('./rpc_invoice_as_invoice');
+const rpcNetworkAsNetworkInfo = require('./rpc_network_as_network_info');
+const rpcNodeAsNode = require('./rpc_node_as_node');
+const rpcOutpointAsUpdate = require('./rpc_outpoint_as_update');
+const rpcPaymentAsPayment = require('./rpc_payment_as_payment');
+const rpcPeerAsPeer = require('./rpc_peer_as_peer');
+const rpcPeerMessageAsMessage = require('./rpc_peer_message_as_message');
+const rpcRequestUpdateAsEvent = require('./rpc_request_update_as_event');
+const rpcResolutionAsResolution = require('./rpc_resolution_as_resolution');
+const rpcRouteAsRoute = require('./rpc_route_as_route');
+const rpcSweepAsSweep = require('./rpc_sweep_as_sweep');
+const rpcTxAsTransaction = require('./rpc_tx_as_transaction');
+const rpcUtxoAsUtxo = require('./rpc_utxo_as_utxo');
+const rpcWalletStateAsState = require('./rpc_wallet_state_as_state');
+
+module.exports = {
+  backupsFromSnapshot,
+  channelAcceptAsOpenRequest,
+  channelEdgeAsChannel,
+  confirmedFromPayment,
+  confirmedFromPaymentStatus,
+  failureFromPayment,
+  forwardFromHtlcEvent,
+  htlcAsPayment,
+  infoAsWalletInfo,
+  nodeInfoAsNode,
+  paymentFailure,
+  paymentRequestDetails,
+  pendingAsPendingChannels,
+  pendingFromPayment,
+  policyFromChannelUpdate,
+  routesFromQueryRoutes,
+  routingFailureFromHtlc,
+  rpcAddressesAsAddresses,
+  rpcAttemptHtlcAsAttempt,
+  rpcChannelAsChannel,
+  rpcChannelClosedAsClosed,
+  rpcChannelUpdateAsUpdate,
+  rpcClosedChannelAsClosed,
+  rpcConfAsConfirmation,
+  rpcFailedPolicyAsFail,
+  rpcFeesAsChannelFees,
+  rpcForwardAsForward,
+  rpcForwardAsForwardRequest,
+  rpcGroupSessionAsSession,
+  rpcHopAsHop,
+  rpcInvoiceAsInvoice,
+  rpcNetworkAsNetworkInfo,
+  rpcNodeAsNode,
+  rpcOutpointAsUpdate,
+  rpcPaymentAsPayment,
+  rpcPeerAsPeer,
+  rpcPeerMessageAsMessage,
+  rpcRequestUpdateAsEvent,
+  rpcResolutionAsResolution,
+  rpcRouteAsRoute,
+  rpcSweepAsSweep,
+  rpcTxAsTransaction,
+  rpcUtxoAsUtxo,
+  rpcWalletStateAsState,
+};

package/lnd_responses/info_as_wallet_info.js

@@ -0,0 +1,117 @@
+const { chainId } = require("../bolt02");
+const { featureFlagDetails } = require("bolt09");
+
+const dateFromEpoch = (epoch) => new Date(epoch * 1e3);
+const { isArray } = Array;
+const isBoolean = (n) => n === false || n === true;
+const isNumber = (n) => !isNaN(n);
+const isString = (n) => typeof n === "string";
+const { keys } = Object;
+
+/** Interpret info as wallet info
+
+  {
+    alias: <Alias String>
+    best_header_timestamp: <Best Header Timestamp Epoch Seconds Number>
+    block_hash: <Best Block Hash Hex String>
+    block_height: <Best Block Height Number>
+    chains: [{
+      chain: <Chain Name String>
+      network: <Network Type String>
+    }]
+    color: <HEX Color String>
+    identity_pubkey: <Node Public Key Hex String>
+    num_active_channels: <Active Channels Count Number>
+    num_peers: <Total Peers Number>
+    num_pending_channels: <Total Pending Channels Number>
+    synced_to_chain: <Node Is Synced To Chain Bool>
+    uris: [<Node URI String>]
+    version: <Node Version String>
+  }
+*/
+module.exports = (args) => {
+  if (!args) {
+    throw new Error("ExpectedWalletResponse");
+  }
+
+  if (!isString(args.alias)) {
+    throw new Error("ExpectedWalletAlias");
+  }
+
+  if (!args.best_header_timestamp) {
+    throw new Error("ExpectedBestHeaderTimestampInInfoResponse");
+  }
+
+  if (!isString(args.block_hash)) {
+    throw new Error("ExpectedCurrentBlockHash");
+  }
+
+  if (!isNumber(args.block_height)) {
+    throw new Error("ExpectedBlockHeight");
+  }
+
+  if (!isArray(args.chains)) {
+    throw new Error("ExpectedChainsAssociatedWithWallet");
+  }
+
+  if (!args.color) {
+    throw new Error("ExpectedWalletColorInWalletInfoResponse");
+  }
+
+  if (!args.features) {
+    throw new Error("ExpectedFeaturesMapInWalletInfoResponse");
+  }
+
+  if (!args.identity_pubkey) {
+    throw new Error("ExpectedIdentityPubkey");
+  }
+
+  if (!isNumber(args.num_active_channels)) {
+    throw new Error("ExpectedNumActiveChannels");
+  }
+
+  if (!isNumber(args.num_peers)) {
+    throw new Error("ExpectedNumPeers");
+  }
+
+  if (!isNumber(args.num_pending_channels)) {
+    throw new Error("ExpectedNumPendingChannels");
+  }
+
+  if (!isBoolean(args.synced_to_chain)) {
+    throw new Error("ExpectedSyncedToChainStatus");
+  }
+
+  if (!isArray(args.uris)) {
+    throw new Error("ExpectedArrayOfUrisInWalletInfoResponse");
+  }
+
+  if (!isString(args.version)) {
+    throw new Error("ExpectedWalletLndVersion");
+  }
+
+  return {
+    chains: args.chains
+      .map(({ chain, network }) => chainId({ chain, network }).chain)
+      .filter((n) => !!n),
+    color: args.color,
+    active_channels_count: args.num_active_channels,
+    alias: args.alias,
+    current_block_hash: args.block_hash,
+    current_block_height: args.block_height,
+    features: keys(args.features).map((bit) => ({
+      bit: Number(bit),
+      is_known: args.features[bit].is_known,
+      is_required: args.features[bit].is_required,
+      type: featureFlagDetails({ bit: Number(bit) }).type,
+    })),
+    is_synced_to_chain: args.synced_to_chain,
+    is_synced_to_graph: !args.synced_to_graph ? undefined : true,
+    latest_block_at: dateFromEpoch(args.best_header_timestamp).toISOString(),
+    peers_count: args.num_peers,
+    pending_channels_count: args.num_pending_channels,
+    public_key: args.identity_pubkey,
+    uris: args.uris,
+    version: args.version,
+  };
+};