astra-lightning 1.0.0

package/lnd_methods/generic/get_route_confidence.js

@@ -0,0 +1,167 @@
+const asyncAuto = require('async/auto');
+const asyncReduce = require('async/reduce');
+const {returnResult} = require('asyncjs-util');
+
+const getForwardingConfidence = require('./../offchain/get_forwarding_confidence');
+const getForwardingReputations = require('./../offchain/get_forwarding_reputations');
+const getIdentity = require('./../info/get_identity');
+
+const combine = (a, b) => Math.round(a / 1e6 * b / 1e6);
+const decBase = 10;
+const defaultOdds = 950000;
+const fullConfidence = 1e6;
+const {isArray} = Array;
+const notFoundIndex = -1;
+const oddsDenominator = BigInt(1e6);
+const unimplemented = 'QueryProbabilityNotImplemented';
+
+/** Get confidence of successfully routing a payment to a destination
+
+  Requires `offchain:read` permission
+
+  If `from` is not set, self is default
+
+  {
+    [from]: <Starting Hex Serialized Public Key>
+    hops: [{
+      forward_mtokens: <Forward Millitokens String>
+      public_key: <Forward Edge Public Key Hex String>
+    }]
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    confidence: <Confidence Score Out Of One Million Number>
+  }
+*/
+module.exports = ({from, hops, lnd}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isArray(hops)) {
+          return cbk([400, 'ExpectedArrayOfHopsToCalculateRoutingOdds']);
+        }
+
+        if (hops.findIndex(n => !n.public_key) !== notFoundIndex) {
+          return cbk([400, 'ExpectedHopsWithEdges']);
+        }
+
+        return cbk();
+      },
+
+      // Get reputations
+      getReputations: ['validate', ({}, cbk) => {
+        return getForwardingReputations({lnd}, cbk);
+      }],
+
+      // Source key
+      source: ['validate', ({}, cbk) => {
+        if (!!from) {
+          return cbk(null, {public_key: from});
+        }
+
+        return getIdentity({lnd}, cbk);
+      }],
+
+      // Forwarding edges
+      forwarding: ['source', ({source}, cbk) => {
+        const forwarding = hops.slice().map((hop, i) => {
+          return {
+            channel: hop.channel,
+            forward_mtokens: hop.forward_mtokens,
+            from_public_key: !i ? source.public_key : hops[i - 1].public_key,
+            to_public_key: hops[i].public_key,
+          };
+        });
+
+        return cbk(null, forwarding.filter(n => !!n.from_public_key));
+      }],
+
+      // Get all confidence scores
+      getScores: ['source', ({source}, cbk) => {
+        const pairs = hops.slice().map((hop, i) => {
+          return {
+            from: !i ? source.public_key : hops[i - 1].public_key,
+            mtokens: hop.forward_mtokens,
+            to: hops[i].public_key,
+          };
+        });
+
+        return asyncReduce(pairs, fullConfidence, (confidence, pair, cbk) => {
+          return getForwardingConfidence({
+            lnd,
+            from: pair.from,
+            mtokens: pair.mtokens,
+            to: pair.to,
+          },
+          (err, res) => {
+            if (!!err) {
+              return cbk(err);
+            }
+
+            return cbk(null, combine(res.confidence, confidence));
+          });
+        },
+        (err, confidence) => {
+          if (!!err) {
+            const [, message] = err;
+
+            return message === unimplemented ? cbk() : cbk(err);
+          }
+
+          return cbk(null, {confidence});
+        });
+      }],
+
+      // Relevant channels
+      odds: [
+        'forwarding',
+        'getReputations',
+        'getScores',
+        ({forwarding, getReputations, getScores}, cbk) =>
+      {
+        const odds = forwarding.map(forward => {
+          const forwardMtokens = BigInt(forward.forward_mtokens);
+
+          const forwardingNode = getReputations.nodes
+            .find(node => node.public_key === forward.from_public_key);
+
+          // Exit early with default odds when node has no reputation at all
+          if (!forwardingNode) {
+            return defaultOdds;
+          }
+
+          const forwardingPeer = forwardingNode.peers
+            .find(peer => peer.to_public_key === forward.to_public_key);
+
+          const forwarding = forwardingPeer;
+
+          // Exit early with general node odds when no chan reputation exists
+          if (!forwarding) {
+            return forwardingNode.confidence || defaultOdds;
+          }
+
+          // Exit early with default odds when reputation is not relevant
+          if (forwardMtokens < BigInt(forwarding.min_relevant_tokens || '0')) {
+            return forwardingNode.confidence;
+          }
+
+          return forwarding.confidence;
+        });
+
+        const totalDenominator = odds.slice(1)
+          .reduce((sum, n) => sum * oddsDenominator, BigInt('1'));
+
+        const totalOdds = odds
+          .reduce((sum, n) => sum * BigInt(n || '0'), BigInt('1'));
+
+        const successOdds = (totalOdds / totalDenominator).toString();
+
+        return cbk(null, {confidence: parseInt(successOdds, decBase)});
+      }],
+    },
+    returnResult({reject, resolve, of: 'odds'}, cbk));
+  });
+};

package/lnd_methods/generic/index.d.ts

@@ -0,0 +1,2 @@
+export * from './get_height';
+export * from './get_route_confidence';

package/lnd_methods/generic/index.js

@@ -0,0 +1,4 @@
+const getHeight = require('./get_height');
+const getRouteConfidence = require('./get_route_confidence');
+
+module.exports = {getHeight, getRouteConfidence};

package/lnd_methods/index.d.ts

@@ -0,0 +1,11 @@
+export * from './address';
+export * from './generic';
+export * from './info';
+export * from './invoices';
+export * from './macaroon';
+export * from './message';
+export * from './offchain';
+export * from './onchain';
+export * from './peers';
+export * from './signer';
+export * from './unauthenticated';

package/lnd_methods/index.js

@@ -0,0 +1,319 @@
+const {addAdvertisedFeature} = require('./peers');
+const {addExternalSocket} = require('./peers');
+const {addPeer} = require('./peers');
+const {beginGroupSigningSession} = require('./signer');
+const {broadcastChainTransaction} = require('./onchain');
+const {cancelHodlInvoice} = require('./invoices');
+const {cancelPendingChannel} = require('./onchain');
+const {changePassword} = require('./unauthenticated');
+const {closeChannel} = require('./onchain');
+const {connectWatchtower} = require('./offchain');
+const {createChainAddress} = require('./address');
+const {createFundedPsbt} = require('./onchain');
+const {createHodlInvoice} = require('./invoices');
+const {createInvoice} = require('./invoices');
+const {createSeed} = require('./unauthenticated');
+const {createWallet} = require('./unauthenticated');
+const {decodePaymentRequest} = require('./offchain');
+const {deleteChainTransaction} = require('./onchain');
+const {deleteFailedPayAttempts} = require('./offchain');
+const {deleteFailedPayments} = require('./offchain');
+const {deleteForwardingReputations} = require('./offchain');
+const {deletePayment} = require('./offchain');
+const {deletePayments} = require('./offchain');
+const {deletePendingChannel} = require('./offchain');
+const {diffieHellmanComputeSecret} = require('./signer');
+const {disableChannel} = require('./offchain');
+const {disconnectWatchtower} = require('./offchain');
+const {enableChannel} = require('./offchain');
+const {endGroupSigningSession} = require('./signer');
+const {fundPendingChannels} = require('./onchain');
+const {fundPsbt} = require('./onchain');
+const {getAccessIds} = require('./macaroon');
+const {getAutopilot} = require('./info');
+const {getBackup} = require('./offchain');
+const {getBackups} = require('./offchain');
+const {getBlock} = require('./onchain');
+const {getBlockHeader} = require('./onchain');
+const {getChainAddresses} = require('./onchain');
+const {getChainBalance} = require('./onchain');
+const {getChainFeeEstimate} = require('./onchain');
+const {getChainFeeRate} = require('./onchain');
+const {getChainTransaction} = require('./onchain');
+const {getChainTransactions} = require('./onchain');
+const {getChannel} = require('./info');
+const {getChannelBalance} = require('./offchain');
+const {getChannels} = require('./offchain');
+const {getClosedChannels} = require('./offchain');
+const {getConfiguration} = require('./info');
+const {getConnectedWatchtowers} = require('./offchain');
+const {getEphemeralChannelIds} = require('./offchain');
+const {getFailedPayments} = require('./offchain');
+const {getFeeRates} = require('./offchain');
+const {getForwardingConfidence} = require('./offchain');
+const {getForwardingReputations} = require('./offchain');
+const {getForwards} = require('./offchain');
+const {getHeight} = require('./generic');
+const {getIdentity} = require('./info');
+const {getInvoice} = require('./invoices');
+const {getInvoices} = require('./invoices');
+const {getLockedUtxos} = require('./onchain');
+const {getMasterPublicKeys} = require('./onchain');
+const {getMethods} = require('./info');
+const {getMinimumRelayFee} = require('./onchain');
+const {getNetworkCentrality} = require('./info');
+const {getNetworkGraph} = require('./info');
+const {getNetworkInfo} = require('./info');
+const {getNode} = require('./info');
+const {getPathfindingSettings} = require('./offchain');
+const {getPayment} = require('./offchain');
+const {getPayments} = require('./offchain');
+const {getPeers} = require('./peers');
+const {getPendingChainBalance} = require('./onchain');
+const {getPendingChannels} = require('./offchain');
+const {getPendingPayments} = require('./offchain');
+const {getPendingSweeps} = require('./onchain');
+const {getPublicKey} = require('./address');
+const {getRouteConfidence} = require('./generic');
+const {getRouteThroughHops} = require('./offchain');
+const {getRouteToDestination} = require('./info');
+const {getSettlementStatus} = require('./offchain');
+const {getSweepTransactions} = require('./onchain');
+const {getTowerServerInfo} = require('./info');
+const {getUtxos} = require('./onchain');
+const {getWalletInfo} = require('./info');
+const {getWalletStatus} = require('./unauthenticated');
+const {getWalletVersion} = require('./info');
+const {grantAccess} = require('./macaroon');
+const {isDestinationPayable} = require('./offchain');
+const {lockUtxo} = require('./onchain');
+const {openChannel} = require('./onchain');
+const {openChannels} = require('./onchain');
+const {partiallySignPsbt} = require('./onchain');
+const {pay} = require('./offchain');
+const {payViaPaymentDetails} = require('./offchain');
+const {payViaPaymentRequest} = require('./offchain');
+const {payViaRequest} = require('./offchain');
+const {payViaRoutes} = require('./offchain');
+const {prepareForChannelProposal} = require('./onchain');
+const {probeForRoute} = require('./offchain');
+const {proposeChannel} = require('./onchain');
+const {recoverFundsFromChannel} = require('./offchain');
+const {recoverFundsFromChannels} = require('./offchain');
+const {removeAdvertisedFeature} = require('./peers');
+const {removeExternalSocket} = require('./peers');
+const {removePeer} = require('./peers');
+const {requestBatchedFeeIncrease} = require('./onchain');
+const {requestChainFeeIncrease} = require('./onchain');
+const {revokeAccess} = require('./macaroon');
+const {sendMessageToPeer} = require('./offchain');
+const {sendToChainAddress} = require('./onchain');
+const {sendToChainAddresses} = require('./onchain');
+const {sendToChainOutputScripts} = require('./onchain');
+const {setAutopilot} = require('./onchain');
+const {settleHodlInvoice} = require('./invoices');
+const {signBytes} = require('./signer');
+const {signChainAddressMessage} = require('./onchain');
+const {signMessage} = require('./message');
+const {signPsbt} = require('./onchain');
+const {signTransaction} = require('./signer');
+const {stopDaemon} = require('./info');
+const {subscribeToBackups} = require('./offchain');
+const {subscribeToBlocks} = require('./onchain');
+const {subscribeToChainAddress} = require('./onchain');
+const {subscribeToChainSpend} = require('./onchain');
+const {subscribeToChannels} = require('./offchain');
+const {subscribeToForwardRequests} = require('./offchain');
+const {subscribeToForwards} = require('./offchain');
+const {subscribeToGraph} = require('./info');
+const {subscribeToInvoice} = require('./invoices');
+const {subscribeToInvoices} = require('./invoices');
+const {subscribeToOpenRequests} = require('./offchain');
+const {subscribeToPastPayment} = require('./offchain');
+const {subscribeToPastPayments} = require('./offchain');
+const {subscribeToPayViaDetails} = require('./offchain');
+const {subscribeToPayViaRequest} = require('./offchain');
+const {subscribeToPayViaRoutes} = require('./offchain');
+const {subscribeToPayments} = require('./offchain');
+const {subscribeToPeerMessages} = require('./offchain');
+const {subscribeToPeers} = require('./peers');
+const {subscribeToProbeForRoute} = require('./offchain');
+const {subscribeToRpcRequests} = require('./macaroon');
+const {subscribeToTransactions} = require('./onchain');
+const {subscribeToWalletStatus} = require('./unauthenticated');
+const {unlockUtxo} = require('./onchain');
+const {unlockWallet} = require('./unauthenticated');
+const {updateAlias} = require('./peers');
+const {updateChainTransaction} = require('./onchain');
+const {updateColor} = require('./peers');
+const {updateConnectedWatchtower} = require('./offchain');
+const {updateGroupSigningSession} = require('./signer');
+const {updatePathfindingSettings} = require('./offchain');
+const {updateRoutingFees} = require('./offchain');
+const {verifyAccess} = require('./macaroon');
+const {verifyBackup} = require('./offchain');
+const {verifyBackups} = require('./offchain');
+const {verifyBytesSignature} = require('./signer');
+const {verifyChainAddressMessage} = require('./onchain');
+const {verifyMessage} = require('./message');
+
+module.exports = {
+  addAdvertisedFeature,
+  addExternalSocket,
+  addPeer,
+  beginGroupSigningSession,
+  broadcastChainTransaction,
+  cancelHodlInvoice,
+  cancelPendingChannel,
+  changePassword,
+  closeChannel,
+  connectWatchtower,
+  createChainAddress,
+  createFundedPsbt,
+  createHodlInvoice,
+  createInvoice,
+  createSeed,
+  createWallet,
+  decodePaymentRequest,
+  deleteChainTransaction,
+  deleteFailedPayAttempts,
+  deleteFailedPayments,
+  deleteForwardingReputations,
+  deletePayment,
+  deletePayments,
+  deletePendingChannel,
+  diffieHellmanComputeSecret,
+  disableChannel,
+  disconnectWatchtower,
+  enableChannel,
+  endGroupSigningSession,
+  fundPendingChannels,
+  fundPsbt,
+  getAccessIds,
+  getAutopilot,
+  getBackup,
+  getBackups,
+  getBlock,
+  getBlockHeader,
+  getChainAddresses,
+  getChainBalance,
+  getChainFeeEstimate,
+  getChainFeeRate,
+  getChainTransaction,
+  getChainTransactions,
+  getChannel,
+  getChannelBalance,
+  getChannels,
+  getClosedChannels,
+  getConfiguration,
+  getConnectedWatchtowers,
+  getEphemeralChannelIds,
+  getFailedPayments,
+  getFeeRates,
+  getForwardingConfidence,
+  getForwardingReputations,
+  getForwards,
+  getHeight,
+  getIdentity,
+  getInvoice,
+  getInvoices,
+  getLockedUtxos,
+  getMasterPublicKeys,
+  getMethods,
+  getMinimumRelayFee,
+  getNetworkCentrality,
+  getNetworkGraph,
+  getNetworkInfo,
+  getNode,
+  getPathfindingSettings,
+  getPayment,
+  getPayments,
+  getPeers,
+  getPendingChainBalance,
+  getPendingChannels,
+  getPendingPayments,
+  getPendingSweeps,
+  getPublicKey,
+  getRouteConfidence,
+  getRouteThroughHops,
+  getRouteToDestination,
+  getSettlementStatus,
+  getSweepTransactions,
+  getTowerServerInfo,
+  getUtxos,
+  getWalletInfo,
+  getWalletStatus,
+  getWalletVersion,
+  grantAccess,
+  isDestinationPayable,
+  lockUtxo,
+  openChannel,
+  openChannels,
+  partiallySignPsbt,
+  pay,
+  payViaPaymentDetails,
+  payViaPaymentRequest,
+  payViaRequest,
+  payViaRoutes,
+  prepareForChannelProposal,
+  probeForRoute,
+  proposeChannel,
+  recoverFundsFromChannel,
+  recoverFundsFromChannels,
+  removeAdvertisedFeature,
+  removeExternalSocket,
+  removePeer,
+  requestBatchedFeeIncrease,
+  requestChainFeeIncrease,
+  revokeAccess,
+  sendMessageToPeer,
+  sendToChainAddress,
+  sendToChainAddresses,
+  sendToChainOutputScripts,
+  setAutopilot,
+  settleHodlInvoice,
+  signBytes,
+  signChainAddressMessage,
+  signMessage,
+  signPsbt,
+  signTransaction,
+  stopDaemon,
+  subscribeToBackups,
+  subscribeToBlocks,
+  subscribeToChainAddress,
+  subscribeToChainSpend,
+  subscribeToChannels,
+  subscribeToForwardRequests,
+  subscribeToForwards,
+  subscribeToGraph,
+  subscribeToInvoice,
+  subscribeToInvoices,
+  subscribeToOpenRequests,
+  subscribeToPastPayment,
+  subscribeToPastPayments,
+  subscribeToPayViaDetails,
+  subscribeToPayViaRequest,
+  subscribeToPayViaRoutes,
+  subscribeToPayments,
+  subscribeToPeerMessages,
+  subscribeToPeers,
+  subscribeToProbeForRoute,
+  subscribeToRpcRequests,
+  subscribeToTransactions,
+  subscribeToWalletStatus,
+  unlockUtxo,
+  unlockWallet,
+  updateAlias,
+  updateChainTransaction,
+  updateColor,
+  updateConnectedWatchtower,
+  updateGroupSigningSession,
+  updatePathfindingSettings,
+  updateRoutingFees,
+  verifyAccess,
+  verifyBackup,
+  verifyBackups,
+  verifyBytesSignature,
+  verifyChainAddressMessage,
+  verifyMessage,
+};

package/lnd_methods/info/constants.json

@@ -0,0 +1,65 @@
+{
+  "blocksBuffer": 6,
+  "defaultCltv": 40,
+  "defaultTokens": 0,
+  "externalType": "externalscore",
+  "maxScore": 100000000,
+  "pathNotFoundErrors": [
+    "ErrNoPathFound",
+    "ErrNoRouteFound",
+    "ErrInsufficientCapacity",
+    "ErrMaxHopsExceeded",
+    "ErrTargetNotInNetwork",
+    "ErrOutdated",
+    "ErrIgnored",
+    "ErrRejected",
+    "ErrPaymentAttemptTimeout",
+    "ErrFeeLimitExceeded"
+  ],
+  "prefAttachType": "preferential",
+  "versions": {
+    "0d5b0fefa4d9082f7964836f5e58c3a6bda8e471": "0.10.2-beta",
+    "13aa7f99248c7ee63989d3b62e0cbfe86d7b0964": "0.17.3-beta",
+    "15c1eb13972f86a7c1e8cb084aa6d52700d685ff": "0.14.5-beta",
+    "1a3194d302f33bb52823297d9d7f75cd37516053": "0.10.0-beta",
+    "1e511be523eb8e97c4e2d9c89a7a263963a3929f": "0.14.2-beta",
+    "2fb150c8fe827df9df0520ef9916b3afb7b03a8d": "0.17.0-beta",
+    "3ae46d81f4a2edad06ef778b2940d9b06386d93b": "0.11.0-beta",
+    "42b856dbb98dee83d284646bfc3eab96199cec62": "0.18.1-beta",
+    "47483f1c66ae6fbb2e03ff29f9bc9b80c611c027": "0.16.3-beta",
+    "4f567577db9d85b6f392f960b3aabddcad3cd02c": "0.13.3-beta",
+    "51df3e5b1ea2f1f749652cecf26e7471d35aa629": "0.16.0-beta",
+    "52bb3f33707b81972c67937c7a89addcdf00991c": "0.10.1-beta",
+    "596fd90ef310cd7abbf2251edaae9ba4d5f8a689": "0.13.1-beta",
+    "5c36d96c9cbe8b27c29f9682dcbdab7928ae870f": "0.15.0-beta",
+    "6042004edaaa5b3cad0a0808ff23dba4716f7178": "0.14.1-beta",
+    "61c34683058f2cc8dc10f49392a0057440d831c4": "0.13.4-beta",
+    "6744c64e628b068e59c3a714d0876f70703df91f": "0.17.2-beta",
+    "6bd30047c1b1188029e8af6ee8a135cf86e7dc4b": "0.16.4-beta",
+    "725ff104808f49f0a5247bfdb4b6b5da7f488d38": "0.13.0-beta",
+    "744feb04e28afdcfa3702a78e83977090c471576": "0.17.1-beta",
+    "7f34774529fa0964d47fc418d4d2965435cbfdc0": "0.11.1-beta",
+    "86d3dec7b939b21bb10f2cd1ff56970c392a1c69": "0.13.2-beta",
+    "86114c575c2dff9dff1e1bb4df961c64aea9fc1c": "0.10.4-beta",
+    "8bba79222f439127e46ec3ff7ec7c650e0d88d56": "0.17.4-beta",
+    "96fe51e2e5c2ee0c97909499e0e96a3d3755757e": "0.15.4-beta",
+    "aff2ed3a6a118d664049835c325a5b69e977172f": "0.15.2-beta",
+    "b4e7131bdb47531ad2f00ce345ddcdb58935bba5": "0.15.3-beta",
+    "bd0c46b4fcb027af1915bd67a3da70e8ca5c6efe": "0.14.3-beta",
+    "c0a09209782b1c62c3393fcea0844e095c25046b": "0.15.5-beta",
+    "d176d2d65fc06e6631c4dc9478592be8545a21de": "0.12.0-beta",
+    "d22b3937eae91d33cd8c035e8fa894e3793e1636": "0.18.2-beta",
+    "d233f61383f2f950aa06f5b09da5b0e78e784fae": "0.12.1-beta",
+    "d62c575f8499a314eb27f12462d20500b6bda2c7": "0.10.3-beta",
+    "d72a3aaf261e278fa4aad5be4453df2f74ab50ee": "0.18.3-beta",
+    "df0b82f0165f19bde8832bacd1e35544b0a2990d": "0.14.0-beta",
+    "eecbe99d68384c734b2c91fd0800484e69c5cab2": "0.14.4-beta",
+    "f8211a2c3b3d2112159cd119bd7674743336c661": "0.17.5-beta",
+    "fb765fdb1daf1c1db08ab9b6aa0c442af431bc82": "0.16.1-beta",
+    "fd1a95bf322cdd1c743a1554f8e470fbf9a5e564": "0.15.1-beta",
+    "fdbeb1e7023827f1cb499a81d474986aa569d945": "0.16.2-beta",
+    "fed760913ff98a89c73414acde6cf29f8728321a": "0.18.0-beta"
+  },
+  "weightedType": "weightedcomb",
+  "wrongLnd": "12 UNIMPLEMENTED: unknown service autopilotrpc.Autopilot"
+}

package/lnd_methods/info/get_autopilot.d.ts

@@ -0,0 +1,43 @@
+import {
+  AuthenticatedLightningArgs,
+  AuthenticatedLightningMethod,
+} from '../../typescript';
+
+export type GetAutopilotArgs = AuthenticatedLightningArgs<{
+  /** Get Score For Public Key Hex String */
+  node_scores?: string[];
+}>;
+
+export type GetAutopilotResult = {
+  /** Autopilot is Enabled */
+  is_enabled: boolean;
+  nodes: {
+    /** Local-adjusted Pref Attachment Score */
+    local_preferential_score: number;
+    /** Local-adjusted Externally Set Score */
+    local_score: number;
+    /** Preferential Attachment Score */
+    preferential_score: number;
+    /** Node Public Key Hex String */
+    public_key: string;
+    /** Externally Set Score */
+    score: number;
+    /** Combined Weighted Locally-Adjusted Score */
+    weighted_local_score: number;
+    /** Combined Weighted Score */
+    weighted_score: number;
+  }[];
+};
+
+/**
+ * Get Autopilot status
+ * 
+ * Optionally, get the score of nodes as considered by the autopilot.
+Local scores reflect an internal scoring that includes local channel info
+ * 
+ * Permission `info:read` is required
+ */
+export const getAutopilot: AuthenticatedLightningMethod<
+  GetAutopilotArgs,
+  GetAutopilotResult
+>;