hodl-lightning 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3ec9c94356d8295384e200f5f75c3f6e31ecf3b51947eda2605553d469581112
+  data.tar.gz: 9ad2917008b21343a4249881f331a1b9a85a1da2160c73dd46885ecdf40ccd7a
+SHA512:
+  metadata.gz: e5707f0604d4ebe373793603ad65613b04785e936f128529472f602ca7a40bab0101c22d18181a3aa95dd09c24a6b381f6a5f0cc07501113f45e5b0a0082e7ee
+  data.tar.gz: 67504ba53627539c89d76914575b995c4b65ebc5ad117d1902528cde20e35e88178ae8ce842ab0664833f0124ab8b88ee1fdaa9f6ea4f893aee75fb04b363455

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.rspec_status
+.DS_Store

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gemspec
+
+gem 'hodl-lnd_grpc', '0.2.0'

data/Gemfile.lock

@@ -0,0 +1,94 @@
+PATH
+  remote: .
+  specs:
+    hodl-lightning (0.2.0)
+      grpc (~> 1.22)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.4.0)
+    builder (3.2.3)
+    byebug (10.0.2)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    diff-lcs (1.3)
+    faraday (0.9.2)
+      multipart-post (>= 1.2, < 3)
+    git (1.5.0)
+    github_api (0.16.0)
+      addressable (~> 2.4.0)
+      descendants_tracker (~> 0.0.4)
+      faraday (~> 0.8, < 0.10)
+      hashie (>= 3.4)
+      mime-types (>= 1.16, < 3.0)
+      oauth2 (~> 1.0)
+    google-protobuf (3.9.0)
+    googleapis-common-protos-types (1.0.4)
+      google-protobuf (~> 3.0)
+    grpc (1.22.0)
+      google-protobuf (~> 3.8)
+      googleapis-common-protos-types (~> 1.0)
+    hashie (3.6.0)
+    highline (2.0.1)
+    hodl-lnd_grpc (0.2.0)
+      grpc (~> 1.22)
+    jeweler (2.3.9)
+      builder
+      bundler
+      git (>= 1.2.5)
+      github_api (~> 0.16.0)
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
+      psych
+      rake
+      rdoc
+      semver2
+    jwt (2.1.0)
+    mime-types (2.99.3)
+    mini_portile2 (2.4.0)
+    multi_json (1.13.1)
+    multi_xml (0.6.0)
+    multipart-post (2.0.0)
+    nokogiri (1.10.1)
+      mini_portile2 (~> 2.4.0)
+    oauth2 (1.4.1)
+      faraday (>= 0.8, < 0.16.0)
+      jwt (>= 1.0, < 3.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (>= 1.2, < 3)
+    psych (3.1.0)
+    rack (2.0.6)
+    rake (10.5.0)
+    rdoc (6.1.1)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    semver2 (3.4.2)
+    thread_safe (0.3.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  byebug
+  hodl-lightning!
+  hodl-lnd_grpc (= 0.2.0)
+  jeweler
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.17.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 dsalamau
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hodl-lightning'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hodl-lightning
+
+## Usage
+
+Configure:
+
+```ruby
+Hodl::Lightning.configure do |config|
+	config.tls_cert_path = "path_to_certificate"
+	config.host = "LND host"
+	config.port = "LND port"
+	config.logger[:level] = :fatal
+end
+```
+
+Find information how to get certificate here - "TODO: Add link to LND docs"
+
+You can call any lnd library method like this:
+
+```ruby
+Hodl::Lightning.server.wallet_balance
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+Then, run `rake spec` to run the tests.
+You could also configure Hodl::Lightning sevrer in `bin/console` file and run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "hodl/lightning"
+require "irb"
+
+# Setup server with your credentials
+Hodl::Lightning.configure do |config|
+	config.tls_cert_path = "spec/vendor/tls.cert"
+	config.host = "127.0.0.1"
+	config.port = "10001"
+  config.logger[:level] = :fatal
+end
+
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/hodl-lightning.gemspec

@@ -0,0 +1,36 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "hodl/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "hodl-lightning"
+  spec.version       = Hodl::Lightning::VERSION
+  spec.authors       = ["dsalamau"]
+  spec.email         = ["salamaudavid@gmail.com"]
+
+  spec.summary       = %q{gRPC client for Lighntning Network Daemon }
+  spec.license       = "MIT"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency             "grpc", "~> 1.22"
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "jeweler"
+end

data/lib/hodl/configuration.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+module Hodl
+  module Lightning
+    class Configuration
+      attr_accessor :tls_cert_path
+      attr_accessor :macaroon_path
+      attr_accessor :host
+      attr_accessor :port
+      attr_accessor :logger
+
+      def initialize
+        # Path to automatically generated cert e.g.: "/Users/dsalamau/Library/Application Support/Lnd/tls.cert"
+        @tls_cert_path = ""
+        # Default host "127.0.0.1"
+        @host          = ""
+        # Default port "10009"
+        @port          = ""
+        # "nil" for unsafe connection
+        @macaroon_path = nil
+        @logger        = {
+                            device: $stdout,
+                            level:  :info,
+                            formatter: nil,
+                          }
+      end
+    end
+  end
+end

data/lib/hodl/lightning.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "logger"
+
+require_relative "configuration"
+require_relative "server"
+require_relative "version"
+
+module Hodl
+  module Lightning
+	  class << self
+	    attr_writer :configuration
+
+	    def configuration
+	      @configuration ||= Configuration.new
+	    end
+
+	    def configure
+	      yield(configuration)
+	    end
+
+	    def logger
+	      return @logger if @logger
+	      @logger = Logger.new(configuration.logger[:device])
+	      @logger.progname = "Hodl::Lightning"
+	      @logger.level = configuration.logger[:level]
+	      @logger.formatter = configuration.logger[:formatter] if configuration.logger[:formatter]
+	      @logger
+	    end
+
+	    def server
+	      @server ||= Server.new(tls_cert_path: configuration.tls_cert_path, host: configuration.host, port: configuration.port)
+	    end
+	  end
+  end
+end

data/lib/hodl/server.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+require "lnd_grpc_services_pb"
+require_relative "server/macaroon_interceptor"
+require_relative "server/services"
+
+module Hodl
+  module Lightning
+    class Server
+      include Hodl::Server::Services
+
+      attr_accessor :tls_cert_path
+      attr_accessor :macaroon_path
+      attr_accessor :host
+      attr_accessor :port
+      attr_accessor :stub
+
+      def initialize(tls_cert_path: nil, host: nil, port: nil, macaroon_path: nil)
+        @tls_cert_path = tls_cert_path || Hodl::Lightning.configuration.tls_cert_path
+        @macaroon_path = macaroon_path || Hodl::Lightning.configuration.macaroon_path
+        @host          = host          || Hodl::Lightning.configuration.host
+        @port          = port          || Hodl::Lightning.configuration.port
+
+        @stub          = stub          || start_server
+      end
+
+      private
+
+      def start_server
+        ENV['GRPC_SSL_CIPHER_SUITES'] = "HIGH+ECDSA"
+
+        if macaroon_path
+          macaroon_binary = File.read(File.expand_path(macaroon_path))
+          macaroon = macaroon_binary.each_byte.map { |b| b.to_s(16).rjust(2,'0') }.join
+        end
+
+        certificate  = File.read(File.expand_path(tls_cert_path))
+        credentials  = GRPC::Core::ChannelCredentials.new(certificate)
+
+        Lnrpc::Lightning::Stub.new("#{host}:#{port}",
+                                   credentials,
+                                   interceptors: macaroon ? [Hodl::Server::MacaroonInterceptor.new(macaroon)] : [])
+      end
+    end
+  end
+end

data/lib/hodl/server/macaroon_interceptor.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+module Hodl
+  module Server
+    class MacaroonInterceptor < GRPC::ClientInterceptor
+      attr_reader :macaroon
+
+      def initialize(macaroon)
+        @macaroon = macaroon
+        super
+      end
+
+      def request_response(request:, call:, method:, metadata:)
+        metadata["macaroon"] = macaroon
+        yield
+      end
+
+      def server_streamer(request:, call:, method:, metadata:)
+        metadata["macaroon"] = macaroon
+        yield
+      end
+    end
+  end
+end

data/lib/hodl/server/services.rb

@@ -0,0 +1,398 @@
+#!/usr/bin/env ruby
+
+module Hodl
+	module Server
+		module Services
+      # WalletBalance returns total unspent outputs(confirmed and unconfirmed), all confirmed unspent outputs and
+      # all unconfirmed unspent outputs under control of the wallet.
+			def wallet_balance
+			  stub.wallet_balance(Lnrpc::WalletBalanceRequest.new)
+			end
+
+      # ChannelBalance returns the total funds available across all open channels in satoshis.
+			def channel_balance
+			  stub.channel_balance(Lnrpc::ChannelBalanceRequest.new)
+			end
+
+      # GetTransactions returns a list describing all the known transactions relevant to the wallet.
+			def get_transactions
+			  stub.get_transactions(Lnrpc::GetTransactionsRequest.new)
+			end
+
+      # SendCoins executes a request to send coins to a particular address.
+      # Unlike SendMany, this RPC call only allows creating a single output at a time.
+      # If neither target_conf, or sat_per_byte are set, then the internal wallet will consult its fee model
+      # to determine a fee for the default confirmation target.
+
+      # Parameters:
+      # addr          string  The address to send coins to
+      # amount        int64   The amount in satoshis to send
+      # target_conf   int32   The target number of blocks that this transaction should be confirmed by.
+      # sat_per_byte  int64   A manual fee rate set in sat/byte that should be used when crafting the transaction.
+      # send_all      bool    If set, then the amount field will be ignored, and lnd will attempt to send all the coins
+      #                       under control of the internal wallet to the specified address.
+			def send_coins(addr:, amount:, target_conf:nil, sat_per_byte:nil, send_all:nil)
+			  stub.send_coins(Lnrpc::SendCoinsRequest.new(addr: addr,
+                                                    amount: amount,
+                                                    target_conf: target_conf,
+                                                    sat_per_byte:sat_per_byte,
+                                                    send_all: send_all))
+			end
+
+
+      # SendMany handles a request for a transaction that creates multiple specified outputs in parallel.
+      # If neither target_conf, or sat_per_byte are set, then the internal wallet will consult its fee model to determine a fee for the default confirmation target.
+
+      # Parameters:
+      # AddrToAmount  array AddrToAmountEntry The map from addresses to amounts
+      # target_conf   int32 The target number of blocks that this transaction should be confirmed by.
+      # sat_per_byte  int64 A manual fee rate set in sat/byte that should be used when crafting the transaction.
+      def send_many(addr_to_amount_array, target_conf:nil, sat_per_byte:nil)
+			  stub.send_many(Lnrpc::SendManyRequest.new(addr_to_amount: addr_to_amount_array,
+                                                  target_conf: target_conf,
+                                                  sat_per_byte: sat_per_byte))
+			end
+
+
+      # ListUnspent returns a list of all utxos spendable by the wallet with a number of confirmations between the specified minimum and maximum.
+
+      # Parameters:
+      # min_confs  int32 The minimum number of confirmations to be included.
+      # max_confs  int32 The maximum number of confirmations to be included.
+      def list_unspent(min_confs:, max_confs:)
+			  stub.list_unspent(Lnrpc::ListUnspentRequest.new(min_confs: min_confs, max_confs: max_confs))
+			end
+
+      # NewAddress creates a new address under control of the local wallet.
+
+      # Parameters:
+      # type  AddressType The address type
+			def new_address(type:)
+			  stub.new_address(Lnrpc::NewAddressRequest.new(type: type))
+			end
+
+      # ConnectPeer attempts to establish a connection to a remote peer.
+      # This is at the networking level, and is used for communication between nodes.
+      # This is distinct from establishing a channel with a peer.
+
+      # Parameters:
+      # addr  LightningAddress  Lightning address of the peer, in the format <pubkey>@host
+      # perm  bool              If set, the daemon will attempt to persistently connect to the target peer.
+      #                         Otherwise, the call will be synchronous.
+			def connect_peer(addr:, perm:nil)
+			  stub.connect_peer(Lnrpc::ConnectPeerRequest.new(addr: addr, perm: perm))
+			end
+
+      # DisconnectPeer attempts to disconnect one peer from another identified by a given pubKey.
+      # In the case that we currently have a pending or active channel with the target peer, then this action will be not be allowed.
+
+      # Parameters:
+      # pub_key string  The pubkey of the node to disconnect from
+			def disconnect_peer(pub_key:)
+			  stub.disconnect_peer(Lnrpc::DisconnectPeerRequest.new(pub_key: pub_key))
+			end
+
+      #ListPeers returns a verbose listing of all currently active peers.
+			def list_peers
+			  stub.list_peers(Lnrpc::ListPeersRequest.new)
+			end
+
+      # GetInfo returns general information concerning the lightning node including
+      # it’s identity pubkey, alias, the chains it is connected to, and information concerning the number of open+pending channels.
+      def get_info
+        stub.get_info(Lnrpc::GetInfoRequest.new)
+      end
+
+      # PendingChannels returns a list of all the channels that are currently considered “pending”.
+      # A channel is pending if it has finished the funding workflow and is waiting for confirmations for the funding txn,
+      # or is in the process of closure, either initiated cooperatively or non-cooperatively.
+			def pending_channels
+			  stub.pending_channels(Lnrpc::PendingChannelsRequest.new)
+			end
+
+      # ListChannels returns a description of all the open channels that this node is a participant in.
+
+      # Parameters:
+      # active_only   bool
+      # inactive_only bool
+      # public_only   bool
+      # private_only  bool
+			def list_channels(active_only:nil, inactive_only:nil, public_only:nil, private_only:nil)
+			  stub.list_channels(Lnrpc::ListChannelsRequest.new(active_only:   active_only,
+                                                          inactive_only: inactive_only,
+                                                          public_only:   public_only,
+                                                          private_only:  private_only))
+			end
+
+      # ClosedChannels returns a description of all the closed channels that this node was a participant in.
+
+      # Parameters:
+      # cooperative      bool
+      # local_force      bool
+      # remote_force     bool
+      # breach           bool
+      # funding_canceled bool
+      # abandoned        bool
+			def closed_channels(cooperative:nil, local_force:nil, remote_force:nil, breach:nil, funding_canceled:nil, abandoned:nil)
+			  stub.closed_channels(Lnrpc::ClosedChannelsRequest.new(cooperative:      cooperative,
+                                                              local_force:      local_force,
+                                                              remote_force:     remote_force,
+                                                              breach:           breach,
+                                                              funding_canceled: funding_canceled,
+                                                              abandoned:        abandoned))
+			end
+
+      #OpenChannel attempts to open a singly funded channel specified in the request to a remote peer.
+      # Users are able to specify a target number of blocks that the funding transaction should be confirmed in,
+      # or a manual fee rate to us for the funding transaction. If neither are specified, then a lax block confirmation target is used.
+
+      # Parameters:
+      # node_pubkey          bytes   The pubkey of the node to open a channel with
+      # node_pubkey_string   string  The hex encoded pubkey of the node to open a channel with
+      # local_funding_amount int64   The number of satoshis the wallet should commit to the channel
+      # push_sat             int64   The number of satoshis to push to the remote side as part of the initial commitment state
+      # target_conf          int32   The target number of blocks that the funding transaction should be confirmed by.
+      # sat_per_byte         int64   A manual fee rate set in sat/byte that should be used when crafting the funding transaction.
+      # private              bool    Whether this channel should be private, not announced to the greater network.
+      # min_htlc_msat        int64   The minimum value in millisatoshi we will require for incoming HTLCs on the channel.
+      # remote_csv_delay     uint32  The delay we require on the remote’s commitment transaction. If this is not set, it will be scaled automatically with the channel size.
+      # min_confs            int32   The minimum number of confirmations each one of your outputs used for the funding transaction must satisfy.
+      # spend_unconfirmed    bool    Whether unconfirmed outputs should be use
+			def open_channel(node_pubkey:nil, node_pubkey_string:, local_funding_amount:, push_sat:nil, target_conf:nil,
+                       sat_per_byte:nil, private_channel:nil, min_htlc_msat:nil, remote_csv_delay:nil, min_confs:nil, spend_unconfirmed:nil)
+			  stub.open_channel(Lnrpc::OpenChannelRequest.new(node_pubkey:          node_pubkey,
+                                                        node_pubkey_string:   node_pubkey_string,
+                                                        local_funding_amount: local_funding_amount,
+                                                        push_sat:             push_sat,
+                                                        target_conf:          target_conf,
+                                                        sat_per_byte:         sat_per_byte,
+                                                        private:              private_channel,
+                                                        min_htlc_msat:        min_htlc_msat,
+                                                        remote_csv_delay:     remote_csv_delay,
+                                                        min_confs:            min_confs,
+                                                        spend_unconfirmed:    spend_unconfirmed))
+			end
+
+      # CloseChannel attempts to close an active channel identified by its channel outpoint (ChannelPoint).
+      # The actions of this method can additionally be augmented to attempt a force close after a timeout period
+      # in the case of an inactive peer. If a non-force close (cooperative closure) is requested,
+      # then the user can specify either a target number of blocks until the closure transaction is confirmed,
+      # or a manual fee rate. If neither are specified, then a default lax, block confirmation target is used.
+
+      # Parameters:
+      # channel_point ChannelPoint  The outpoint (txid:index) of the funding transaction. With this value, Bob will be able to generate a signature for Alice’s version of the commitment transaction.
+      # force         bool          If true, then the channel will be closed forcibly. This means the current commitment transaction will be signed and broadcast.
+      # target_conf   int32         The target number of blocks that the closure transaction should be confirmed by.
+      # sat_per_byte  int64         A manual fee rate set in sat/byte that should be used when crafting the closure transaction.
+			def close_channel(channel_point:, force:nil, target_conf:nil, sat_per_byte:nil)
+			  stub.close_channel(Lnrpc::CloseChannelRequest.new(channel_point: channel_point,
+                                                          force:         force,
+                                                          target_conf:   target_conf,
+                                                          sat_per_byte:  sat_per_byte))
+			end
+
+      #AbandonChannel removes all channel state from the database except for a close summary.
+      # This method can be used to get rid of permanently unusable channels due to bugs fixed in newer versions of lnd.
+      # Only available when in debug builds of lnd.
+
+      # Parameters:
+      # channel_point ChannelPoint
+			def abandon_channel(channel_point:)
+			  stub.abandon_channel(Lnrpc::AbandonChannelRequest.new(channel_point: channel_point))
+			end
+
+      # SendPaymentSync is the synchronous non-streaming version of SendPayment.
+      # This RPC is intended to be consumed by clients of the REST proxy.
+      # Additionally, this RPC expects the destination’s public key and the payment hash (if any) to be encoded as hex strings.
+
+      # Parameters:
+      # dest                bytes     The identity pubkey of the payment recipient
+      # dest_string         string    The hex-encoded identity pubkey of the payment recipient
+      # amt                 int64     Number of satoshis to send.
+      # payment_hash        bytes     The hash to use within the payment’s HTLC
+      # payment_hash_string string    The hex-encoded hash to use within the payment’s HTLC
+      # payment_request     string    A bare-bones invoice for a payment within the Lightning Network. With the details of the invoice, the sender has all the data necessary to send a payment to the recipient.
+      # final_cltv_delta    int32     The CLTV delta from the current height that should be used to set the timelock for the final hop.
+      # fee_limit           FeeLimit  The maximum number of satoshis that will be paid as a fee of the payment. This value can be represented either as a percentage of the amount being sent, or as a fixed amount of the maximum fee the user is willing the pay to send the payment.
+      # outgoing_chan_id    uint64    The channel id of the channel that must be taken to the first hop. If zero, any channel may be used.
+      # cltv_limit          uint32    An optional maximum total time lock for the route. If zero, there is no maximum enforced.
+			def send_payment_sync(dest:nil, dest_string:nil, amt:nil, payment_hash:nil, payment_hash_string:nil, payment_request:nil,
+                            final_cltv_delta:nil, fee_limit:nil, outgoing_chan_id:nil, cltv_limit:nil)
+        stub.send_payment_sync(Lnrpc::SendRequest.new(dest:                dest,
+                                                      dest_string:         dest_string,
+                                                      amt:                 amt,
+                                                      payment_hash:        payment_hash,
+                                                      payment_hash_string: payment_hash_string,
+                                                      payment_request:     payment_request,
+                                                      final_cltv_delta:    final_cltv_delta,
+                                                      fee_limit:           Lnrpc::FeeLimit.new(fixed: fee_limit)))
+			end
+
+      # AddInvoice attempts to add a new invoice to the invoice database.
+      # Any duplicated invoices are rejected, therefore all invoices must have a unique payment preimage.
+
+      # Parameters:
+      # memo              string  An optional memo to attach along with the invoice. Used for record keeping purposes for the invoice’s creator, and will also be set in the description field of the encoded payment request if the description_hash field is not being used.
+      # r_preimage        bytes   The hex-encoded preimage (32 byte) which will allow settling an incoming HTLC payable to this preimage
+      # r_hash            bytes   The hash of the preimage
+      # value             int64   The value of this invoice in satoshis
+      # settled           bool    Whether this invoice has been fulfilled
+      # creation_date     int64   When this invoice was created
+      # settle_date       int64   When this invoice was settled
+      # payment_request   string  A bare-bones invoice for a payment within the Lightning Network. With the details of the invoice, the sender has all the data necessary to send a payment to the recipient.
+      # description_hash  bytes   Hash (SHA-256) of a description of the payment. Used if the description of payment (memo) is too long to naturally fit within the description field of an encoded payment request.
+      # expiry            int64   Payment request expiry time in seconds. Default is 3600 (1 hour).
+      # fallback_addr     string  Fallback on-chain address.
+      # cltv_expiry       uint64  Delta to use for the time-lock of the CLTV extended to the final hop.
+      # route_hints       array   RouteHint Route hints that can each be individually used to assist in reaching the invoice’s destination.
+      # private           bool    Whether this invoice should include routing hints for private channels.
+      # add_index         uint64  The “add” index of this invoice. Each newly created invoice will increment this index making it monotonically increasing. Callers to the SubscribeInvoices call can use this to instantly get notified of all added invoices with an add_index greater than this one.
+      # settle_index      uint64  The “settle” index of this invoice. Each newly settled invoice will increment this index making it monotonically increasing. Callers to the SubscribeInvoices call can use this to instantly get notified of all settled invoices with an settle_index greater than this one.
+      # amt_paid_sat      int64   The amount that was accepted for this invoice, in satoshis. This will ONLY be set if this invoice has been settled. We provide this field as if the invoice was created with a zero value, then we need to record what amount was ultimately accepted. Additionally, it’s possible that the sender paid MORE that was specified in the original invoice. So we’ll record that here as well.
+      # amt_paid_msat     int64   The amount that was accepted for this invoice, in millisatoshis. This will ONLY be set if this invoice has been settled. We provide this field as if the invoice was created with a zero value, then we need to record what amount was ultimately accepted. Additionally, it’s possible that the sender paid MORE that was specified in the original invoice. So we’ll record that here as well.
+      # state             InvoiceState
+			def add_invoice(memo:nil, r_preimage:nil, r_hash:nil, value:nil, settled:nil, creation_date:nil, settle_date:nil, payment_request:nil, description_hash:nil, expiry:nil,
+                      fallback_addr:nil, cltv_expiry:nil, route_hints:nil, private_invoice:nil, add_index:nil, settle_index:nil, amt_paid_sat:nil, amt_paid_msat:nil, state:nil)
+				stub.add_invoice(Lnrpc::Invoice.new(memo: memo,
+                                            r_preimage: r_preimage,
+                                            r_hash: r_hash,
+                                            value: value,
+                                            settled: settled,
+                                            creation_date: creation_date,
+                                            settle_date: settle_date,
+                                            payment_request: payment_request,
+                                            description_hash: description_hash,
+                                            expiry: expiry,
+                                            fallback_addr: fallback_addr,
+                                            cltv_expiry: cltv_expiry,
+                                            route_hints: route_hints,
+                                            private: private_invoice,
+                                            add_index: add_index,
+                                            settle_index: settle_index,
+                                            amt_paid_sat: amt_paid_sat,
+                                            amt_paid_msat: amt_paid_msat,
+                                            state: state))
+			end
+
+      # ListInvoices returns a list of all the invoices currently stored within the database.
+      # Any active debug invoices are ignored. It has full support for paginated responses,
+      # allowing users to query for specific invoices through their add_index.
+      # This can be done by using either the first_index_offset or last_index_offset fields included
+      # in the response as the index_offset of the next request. By default, the first 100 invoices created will be returned.
+      # Backwards pagination is also supported through the Reversed flag.
+
+      # Parameters:
+      # pending_only     bool    If set, only unsettled invoices will be returned in the response.
+      # index_offset     uint64  The index of an invoice that will be used as either the start or end of a query to determine which invoices should be returned in the response.
+      # um_max_invoices  uint64  The max number of invoices to return in the response to this query.
+      # reversed         bool    If set, the invoices returned will result from seeking backwards from the specified index offset. This can be used to paginate backwards.
+			def list_invoices(pending_only:nil, index_offset:nil, um_max_invoices:nil, reversed: nil)
+				stub.list_invoices(Lnrpc::ListInvoiceRequest.new(pending_only:    pending_only,
+                                                         index_offset:    index_offset,
+                                                         um_max_invoices: um_max_invoices,
+                                                         reversed:        reversed))
+			end
+
+      # LookupInvoice attempts to look up an invoice according to its payment hash.
+      # The passed payment hash must be exactly 32 bytes, if not, an error is returned.
+
+      # Parameters
+      # r_hash_str  string  The hex-encoded payment hash of the invoice to be looked up. The passed payment hash must be exactly 32 bytes, otherwise an error is returned.
+      # r_hash      bytes   The payment hash of the invoice to be looked up.
+			def lookup_invoice(r_hash_str: nil, r_hash: nil)
+				stub.lookup_invoice(Lnrpc::PaymentHash.new(r_hash_str: r_hash_str,
+                                                   r_hash: r_hash))
+			end
+
+      # DecodePayReq takes an encoded payment request string and attempts to decode it,
+      # returning a full description of the conditions encoded within the payment request.
+
+      # Parameters
+      # pay_req string  The payment request string to be decoded
+      def decode_pay_req(pay_req:)
+        stub.decode_pay_req(Lnrpc::PayReqString.new(pay_req: pay_req))
+      end
+
+      # ListPayments returns a list of all outgoing payments.
+      def list_payments
+        stub.list_payments(Lnrpc::PayReqString.new)
+      end
+
+      # DeleteAllPayments deletes all outgoing payments from DB.
+      def delete_all_payments(confirmed:false)
+        stub.delete_all_payments(Lnrpc::DeleteAllPaymentsRequest.new) if confirmed
+      end
+
+      # GetChanInfo returns the latest authenticated network announcement for the given channel
+      # identified by its channel ID: an 8-byte integer which uniquely identifies the location of transaction’s
+      # funding output within the blockchain.
+
+      # Parameters
+      # chan_id uint64  The unique channel ID for the channel. The first 3 bytes are the block height, the next 3 the index within the block, and the last 2 bytes are the output index for the channel.
+      def get_chan_info(chan_id:)
+        stub.get_chan_info(Lnrpc::ChanInfoRequest.new(chan_id: chan_id))
+      end
+
+      # GetNodeInfo returns the latest advertised, aggregated, and authenticated channel information
+      # for the specified node identified by its public key.
+
+      # Parameters
+      # pub_key string  The 33-byte hex-encoded compressed public of the target node
+      def get_node_info(pub_key:)
+        stub.get_node_info(Lnrpc::NodeInfoRequest.new(pub_key: pub_key))
+      end
+
+      # QueryRoutes attempts to query the daemon’s Channel Router for a possible route to a target destination capable of carrying a specific amount of satoshis.
+      # The retuned route contains the full details required to craft and send an HTLC, also including the necessary information that should be present within the Sphinx packet encapsulated within the HTLC.
+
+      # Parameters
+      # pub_key           string    The 33-byte hex-encoded public key for the payment destination
+      # amt               int64     The amount to send expressed in satoshis
+      # final_cltv_delta  int32     An optional CLTV delta from the current height that should be used for the timelock of the final hop
+      # fee_limit         FeeLimit  The maximum number of satoshis that will be paid as a fee of the payment. This value can be represented either as a percentage of the amount being sent, or as a fixed amount of the maximum fee the user is willing the pay to send the payment.
+      # ignored_nodes     array     bytes A list of nodes to ignore during path finding.
+      # ignored_edges     array     EdgeLocator A list of edges to ignore during path finding.
+      # source_pub_key    string    The source node where the request route should originated from. If empty, self is assumed.
+      def query_routes(pub_key:nil, amt:nil, final_cltv_delta:nil, fee_limit:nil, ignored_edges:nil, source_pub_key:nil, ignored_nodes:nil)
+        stub.query_routes(Lnrpc::QueryRoutesRequest.new(pub_key:          pub_key,
+                                                        amt:              amt,
+                                                        final_cltv_delta: final_cltv_delta,
+                                                        fee_limit:        fee_limit,
+                                                        ignored_nodes:    ignored_nodes,
+                                                        ignored_edges:    ignored_edges,
+                                                        source_pub_key:   source_pub_key))
+      end
+
+      # GetNetworkInfo returns some basic stats about the known channel graph from the point of view of the node.
+      def get_network_info
+        stub.get_network_info(Lnrpc::NetworkInfoRequest.new)
+      end
+
+      # StopDaemon will send a shutdown request to the interrupt handler, triggering a graceful shutdown of the daemon.
+      def stop_daemon(confirmed:false)
+        stub.stop_daemon(Lnrpc::StopRequest.new) if confirmed
+      end
+
+      # FeeReport allows the caller to obtain a report detailing the current fee schedule enforced by the node globally for each channel.
+      def fee_report
+        stub.fee_report(Lnrpc::FeeReportRequest.new)
+      end
+
+      # UpdateChannelPolicy allows the caller to update the fee schedule and channel policies for all channels globally, or a particular channel.
+
+      # Parameters
+      # global          bool          If set, then this update applies to all currently active channels.
+      # chan_point      ChannelPoint  If set, this update will target a specific channel.
+      # base_fee_msat   int64         The base fee charged regardless of the number of milli-satoshis sent.
+      # fee_rate        double        The effective fee rate in milli-satoshis. The precision of this value goes up to 6 decimal places, so 1e-6.
+      # time_lock_delta uint32        The required timelock delta for HTLCs forwarded over the channel.
+      def update_channel_policy(global:nil, chan_point:nil, base_fee_msat:nil, fee_rate:nil, time_lock_delta:nil)
+        stub.update_channel_policy(Lnrpc::PolicyUpdateRequest.new(global:          global,
+                                                                  chan_point:      chan_point,
+                                                                  base_fee_msat:   base_fee_msat,
+                                                                  fee_rate:        fee_rate,
+                                                                  time_lock_delta: time_lock_delta))
+      end
+		end
+	end
+end

data/lib/hodl/version.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+module Hodl
+  module Lightning
+    VERSION = "0.2.0"
+  end
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: hodl-lightning
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- dsalamau
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-10-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: grpc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.22'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- salamaudavid@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- hodl-lightning.gemspec
+- lib/hodl/configuration.rb
+- lib/hodl/lightning.rb
+- lib/hodl/server.rb
+- lib/hodl/server/macaroon_interceptor.rb
+- lib/hodl/server/services.rb
+- lib/hodl/version.rb
+homepage: 
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: gRPC client for Lighntning Network Daemon
+test_files: []