astra-lightning 1.0.0

package/bolt02/ids.json

@@ -0,0 +1,11 @@
+{
+  "chains": {
+    "bitcoinmainnet": "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
+    "bitcoinregtest": "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206",
+    "bitcoinsignet": "00000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6",
+    "bitcointestnet": "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943",
+    "litecoinmainnet": "12a765e31ffd4059bada1e25190f6e98c99d9714d334efa41a195a7e7e04bfe2",
+    "litecoinregtest": "530827f38f93b43ed12af0b3ad25a288dc02ed74d6d7857862df51fc56c416f9",
+    "litecointestnet": "4966625a4b2851d9fdee139e56211a0d88575f59ed816ff5e6a63deb4e3e29a0"
+  }
+}

package/bolt02/index.js

@@ -0,0 +1,3 @@
+const chainId = require('./chain_id');
+
+module.exports = {chainId};

package/grpc/emit_subscription_error.js

@@ -0,0 +1,28 @@
+const cancelError = 'Cancelled on client';
+
+/** Get a function that emits an error from a gRPC subscription proxy
+
+  {
+    emitter: <Event Subscription Proxy Object>
+    subscription: <gRPC Subscription Object>
+  }
+
+  @returns
+  <Error Emission Function>
+*/
+module.exports = ({emitter, subscription}) => {
+  return err => {
+    subscription.cancel();
+
+    if (!!err && err.details === cancelError) {
+      subscription.removeAllListeners();
+    }
+
+    // Exit early when there are no error listeners
+    if (!emitter.listenerCount('error')) {
+      return;
+    }
+
+    return emitter.emit('error', err);
+  };
+};

package/grpc/grpc_services.json

@@ -0,0 +1,63 @@
+{
+  "defaultSocket": "localhost:10009",
+  "grpcSslCipherSuites": "HIGH+ECDSA:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384",
+  "maxReceiveMessageLength": 924288000,
+  "packageTypes": {
+    "Autopilot": "autopilotrpc",
+    "ChainKit": "chainrpc",
+    "ChainNotifier": "chainrpc",
+    "Invoices": "invoicesrpc",
+    "Lightning": "lnrpc",
+    "Peers": "peersrpc",
+    "Router": "routerrpc",
+    "Signer": "signrpc",
+    "State": "lnrpc",
+    "Versioner": "verrpc",
+    "WalletUnlocker": "lnrpc",
+    "WalletKit": "walletrpc",
+    "Watchtower": "watchtowerrpc",
+    "WatchtowerClient": "wtclientrpc",
+    "TaprootAssetChannels":"tapchannelrpc"
+  },
+  "protoFiles": {
+    "Autopilot": "autopilot.proto",
+    "ChainKit": "chainkit.proto",
+    "ChainNotifier": "chainnotifier.proto",
+    "Invoices": "invoices.proto",
+    "Lightning": "lightning.proto",
+    "Peers": "peers.proto",
+    "Router": "router.proto",
+    "Signer": "signer.proto",
+    "State": "stateservice.proto",
+    "Versioner": "verrpc.proto",
+    "WalletUnlocker": "walletunlocker.proto",
+    "WalletKit": "walletkit.proto",
+    "Watchtower": "watchtower.proto",
+    "WatchtowerClient": "wtclient.proto",
+    "TaprootAssetChannels":"taprootassetchannels.proto"
+  },
+  "protosDir": "../grpc/protos",
+  "serviceTypes": {
+    "autopilot": "Autopilot",
+    "blocks": "ChainKit",
+    "chain": "ChainNotifier",
+    "default": "Lightning",
+    "invoices": "Invoices",
+    "peers": "Peers",
+    "router": "Router",
+    "signer": "Signer",
+    "tower_client": "WatchtowerClient",
+    "tower_server": "Watchtower",
+    "version": "Versioner",
+    "wallet": "WalletKit",
+    "taproot_asset_channels": "TaprootAssetChannels"
+  },
+  "unauthenticatedPackageTypes": {
+    "State": "lnrpc",
+    "WalletUnlocker": "lnrpc"
+  },
+  "unauthenticatedServiceTypes": {
+    "status": "State",
+    "unlocker": "WalletUnlocker"
+  }
+}

package/grpc/handle_remove_listener.js

@@ -0,0 +1,25 @@
+const sumOf = arr => arr.reduce((sum, n) => sum + n, Number());
+
+/** Get a function that emits an error from a gRPC subscription proxy
+
+  {
+    emitter: <EventEmitter Subscription Proxy Object>
+    events: [<Event Name String>]
+    subscription: <gRPC Subscription Object>
+  }
+*/
+module.exports = ({emitter, events, subscription}) => {
+  // Cancel the subscription when all listeners are removed
+  emitter.on('removeListener', () => {
+    const counts = events.map(n => emitter.listenerCount(n));
+
+    // Exit early when there are still active listeners
+    if (!!sumOf(counts)) {
+      return;
+    }
+
+    subscription.cancel();
+
+    return;
+  });
+};

package/grpc/index.js

@@ -0,0 +1,25 @@
+const {defaultSocket} = require('./grpc_services');
+const emitSubscriptionError = require('./emit_subscription_error');
+const {grpcSslCipherSuites} = require('./grpc_services');
+const handleRemoveListener = require('./handle_remove_listener');
+const {maxReceiveMessageLength} = require('./grpc_services');
+const {packageTypes} = require('./grpc_services');
+const {protoFiles} = require('./grpc_services');
+const {protosDir} = require('./grpc_services');
+const {serviceTypes} = require('./grpc_services');
+const {unauthenticatedPackageTypes} = require('./grpc_services');
+const {unauthenticatedServiceTypes} = require('./grpc_services');
+
+module.exports = {
+  defaultSocket,
+  emitSubscriptionError,
+  grpcSslCipherSuites,
+  handleRemoveListener,
+  maxReceiveMessageLength,
+  packageTypes,
+  protoFiles,
+  protosDir,
+  serviceTypes,
+  unauthenticatedPackageTypes,
+  unauthenticatedServiceTypes,
+};

package/grpc/protos/autopilot.proto

@@ -0,0 +1,98 @@
+syntax = "proto3";
+
+package autopilotrpc;
+
+option go_package = "github.com/lightningnetwork/lnd/lnrpc/autopilotrpc";
+
+/*
+ * Comments in this file will be directly parsed into the API
+ * Documentation as descriptions of the associated method, message, or field.
+ * These descriptions should go right above the definition of the object, and
+ * can be in either block or // comment format.
+ *
+ * An RPC method can be matched to an lncli command by placing a line in the
+ * beginning of the description in exactly the following format:
+ * lncli: `methodname`
+ *
+ * Failure to specify the exact name of the command will cause documentation
+ * generation to fail.
+ *
+ * More information on how exactly the gRPC documentation is generated from
+ * this proto file can be found here:
+ * https://github.com/lightninglabs/lightning-api
+ */
+
+// Autopilot is a service that can be used to get information about the current
+// state of the daemon's autopilot agent, and also supply it with information
+// that can be used when deciding where to open channels.
+service Autopilot {
+    /* lncli: `autopilot status`
+    Status returns whether the daemon's autopilot agent is active.
+    */
+    rpc Status (StatusRequest) returns (StatusResponse);
+
+    /*
+    ModifyStatus is used to modify the status of the autopilot agent, like
+    enabling or disabling it.
+    */
+    rpc ModifyStatus (ModifyStatusRequest) returns (ModifyStatusResponse);
+
+    /* lncli: `autopilot query`
+    QueryScores queries all available autopilot heuristics, in addition to any
+    active combination of these heruristics, for the scores they would give to
+    the given nodes.
+    */
+    rpc QueryScores (QueryScoresRequest) returns (QueryScoresResponse);
+
+    /*
+    SetScores attempts to set the scores used by the running autopilot agent,
+    if the external scoring heuristic is enabled.
+    */
+    rpc SetScores (SetScoresRequest) returns (SetScoresResponse);
+}
+
+message StatusRequest {
+}
+
+message StatusResponse {
+    // Indicates whether the autopilot is active or not.
+    bool active = 1;
+}
+
+message ModifyStatusRequest {
+    // Whether the autopilot agent should be enabled or not.
+    bool enable = 1;
+}
+
+message ModifyStatusResponse {
+}
+
+message QueryScoresRequest {
+    repeated string pubkeys = 1;
+
+    // If set, we will ignore the local channel state when calculating scores.
+    bool ignore_local_state = 2;
+}
+
+message QueryScoresResponse {
+    message HeuristicResult {
+        string heuristic = 1;
+        map<string, double> scores = 2;
+    }
+
+    repeated HeuristicResult results = 1;
+}
+
+message SetScoresRequest {
+    // The name of the heuristic to provide scores to.
+    string heuristic = 1;
+
+    /*
+    A map from hex-encoded public keys to scores. Scores must be in the range
+    [0.0, 1.0].
+    */
+    map<string, double> scores = 2;
+}
+
+message SetScoresResponse {
+}

package/grpc/protos/chainkit.proto

@@ -0,0 +1,74 @@
+syntax = "proto3";
+
+package chainrpc;
+
+option go_package = "github.com/lightningnetwork/lnd/lnrpc/chainrpc";
+
+// ChainKit is a service that can be used to get information from the
+// chain backend.
+service ChainKit {
+    /* lncli: `chain getblock`
+    GetBlock returns a block given the corresponding block hash.
+    */
+    rpc GetBlock (GetBlockRequest) returns (GetBlockResponse);
+
+    /* lncli: `chain getblockheader`
+    GetBlockHeader returns a block header with a particular block hash.
+    */
+    rpc GetBlockHeader (GetBlockHeaderRequest) returns (GetBlockHeaderResponse);
+
+    /* lncli: `chain getbestblock`
+    GetBestBlock returns the block hash and current height from the valid
+    most-work chain.
+    */
+    rpc GetBestBlock (GetBestBlockRequest) returns (GetBestBlockResponse);
+
+    /* lncli: `chain getblockhash`
+    GetBlockHash returns the hash of the block in the best blockchain
+    at the given height.
+    */
+    rpc GetBlockHash (GetBlockHashRequest) returns (GetBlockHashResponse);
+}
+
+message GetBlockRequest {
+    // The hash of the requested block.
+    bytes block_hash = 1;
+}
+
+// TODO(ffranr): The neutrino GetBlock response includes many
+// additional helpful fields. Consider adding them here also.
+message GetBlockResponse {
+    // The raw bytes of the requested block.
+    bytes raw_block = 1;
+}
+
+message GetBlockHeaderRequest {
+    // The hash of the block with the requested header.
+    bytes block_hash = 1;
+}
+
+message GetBlockHeaderResponse {
+    // The header of the block with the requested hash.
+    bytes raw_block_header = 1;
+}
+
+message GetBestBlockRequest {
+}
+
+message GetBestBlockResponse {
+    // The hash of the best block.
+    bytes block_hash = 1;
+
+    // The height of the best block.
+    int32 block_height = 2;
+}
+
+message GetBlockHashRequest {
+    // Block height of the target best chain block.
+    int64 block_height = 1;
+}
+
+message GetBlockHashResponse {
+    // The hash of the best block at the specified height.
+    bytes block_hash = 1;
+}

package/grpc/protos/chainnotifier.proto

@@ -0,0 +1,200 @@
+syntax = "proto3";
+
+package chainrpc;
+
+option go_package = "github.com/lightningnetwork/lnd/lnrpc/chainrpc";
+
+// ChainNotifier is a service that can be used to get information about the
+// chain backend by registering notifiers for chain events.
+service ChainNotifier {
+    /*
+    RegisterConfirmationsNtfn is a synchronous response-streaming RPC that
+    registers an intent for a client to be notified once a confirmation request
+    has reached its required number of confirmations on-chain.
+
+    A confirmation request must have a valid output script. It is also possible
+    to give a transaction ID. If the transaction ID is not set, a notification
+    is sent once the output script confirms. If the transaction ID is also set,
+    a notification is sent once the output script confirms in the given
+    transaction.
+    */
+    rpc RegisterConfirmationsNtfn (ConfRequest) returns (stream ConfEvent);
+
+    /*
+    RegisterSpendNtfn is a synchronous response-streaming RPC that registers an
+    intent for a client to be notification once a spend request has been spent
+    by a transaction that has confirmed on-chain.
+
+    A client can specify whether the spend request should be for a particular
+    outpoint  or for an output script by specifying a zero outpoint.
+    */
+    rpc RegisterSpendNtfn (SpendRequest) returns (stream SpendEvent);
+
+    /*
+    RegisterBlockEpochNtfn is a synchronous response-streaming RPC that
+    registers an intent for a client to be notified of blocks in the chain. The
+    stream will return a hash and height tuple of a block for each new/stale
+    block in the chain. It is the client's responsibility to determine whether
+    the tuple returned is for a new or stale block in the chain.
+
+    A client can also request a historical backlog of blocks from a particular
+    point. This allows clients to be idempotent by ensuring that they do not
+    missing processing a single block within the chain.
+    */
+    rpc RegisterBlockEpochNtfn (BlockEpoch) returns (stream BlockEpoch);
+}
+
+message ConfRequest {
+    /*
+    The transaction hash for which we should request a confirmation notification
+    for. If set to a hash of all zeros, then the confirmation notification will
+    be requested for the script instead.
+    */
+    bytes txid = 1;
+
+    /*
+    An output script within a transaction with the hash above which will be used
+    by light clients to match block filters. If the transaction hash is set to a
+    hash of all zeros, then a confirmation notification will be requested for
+    this script instead.
+    */
+    bytes script = 2;
+
+    /*
+    The number of desired confirmations the transaction/output script should
+    reach before dispatching a confirmation notification.
+    */
+    uint32 num_confs = 3;
+
+    /*
+    The earliest height in the chain for which the transaction/output script
+    could have been included in a block. This should in most cases be set to the
+    broadcast height of the transaction/output script.
+    */
+    uint32 height_hint = 4;
+
+    /*
+    If true, then the block that mines the specified txid/script will be
+    included in eventual the notification event.
+    */
+    bool include_block = 5;
+}
+
+message ConfDetails {
+    // The raw bytes of the confirmed transaction.
+    bytes raw_tx = 1;
+
+    // The hash of the block in which the confirmed transaction was included in.
+    bytes block_hash = 2;
+
+    // The height of the block in which the confirmed transaction was included
+    // in.
+    uint32 block_height = 3;
+
+    // The index of the confirmed transaction within the block.
+    uint32 tx_index = 4;
+
+    /*
+    The raw bytes of the block that mined the transaction. Only included if
+    include_block was set in the request.
+    */
+    bytes raw_block = 5;
+}
+
+message Reorg {
+    // TODO(wilmer): need to know how the client will use this first.
+}
+
+message ConfEvent {
+    oneof event {
+        /*
+        An event that includes the confirmation details of the request
+        (txid/ouput script).
+        */
+        ConfDetails conf = 1;
+
+        /*
+        An event send when the transaction of the request is reorged out of the
+        chain.
+        */
+        Reorg reorg = 2;
+    }
+}
+
+message Outpoint {
+    // The hash of the transaction.
+    bytes hash = 1;
+
+    // The index of the output within the transaction.
+    uint32 index = 2;
+}
+
+message SpendRequest {
+    /*
+    The outpoint for which we should request a spend notification for. If set to
+    a zero outpoint, then the spend notification will be requested for the
+    script instead. A zero or nil outpoint is not supported for Taproot spends
+    because the output script cannot reliably be computed from the witness alone
+    and the spent output script is not always available in the rescan context.
+    So an outpoint must _always_ be specified when registering a spend
+    notification for a Taproot output.
+    */
+    Outpoint outpoint = 1;
+
+    /*
+    The output script for the outpoint above. This will be used by light clients
+    to match block filters. If the outpoint is set to a zero outpoint, then a
+    spend notification will be requested for this script instead.
+    */
+    bytes script = 2;
+
+    /*
+    The earliest height in the chain for which the outpoint/output script could
+    have been spent. This should in most cases be set to the broadcast height of
+    the outpoint/output script.
+    */
+    uint32 height_hint = 3;
+
+    // TODO(wilmer): extend to support num confs on spending tx.
+}
+
+message SpendDetails {
+    // The outpoint was that spent.
+    Outpoint spending_outpoint = 1;
+
+    // The raw bytes of the spending transaction.
+    bytes raw_spending_tx = 2;
+
+    // The hash of the spending transaction.
+    bytes spending_tx_hash = 3;
+
+    // The input of the spending transaction that fulfilled the spend request.
+    uint32 spending_input_index = 4;
+
+    // The height at which the spending transaction was included in a block.
+    uint32 spending_height = 5;
+}
+
+message SpendEvent {
+    oneof event {
+        /*
+        An event that includes the details of the spending transaction of the
+        request (outpoint/output script).
+        */
+        SpendDetails spend = 1;
+
+        /*
+        An event sent when the spending transaction of the request was
+        reorged out of the chain.
+        */
+        Reorg reorg = 2;
+    }
+}
+
+message BlockEpoch {
+    // The hash of the block.
+    bytes hash = 1;
+
+    // The height of the block.
+    uint32 height = 2;
+}