Browse Source

hello lnd world

pull/4/head
bumi 3 years ago
commit
669a0dff80
  1. 13
      .gitignore
  2. 3
      .rspec
  3. 6
      Gemfile
  4. 42
      Gemfile.lock
  5. 21
      LICENSE.txt
  6. 39
      README.md
  7. 6
      Rakefile
  8. 14
      bin/console
  9. 8
      bin/setup
  10. 8
      lib/lnrpc.rb
  11. 35
      lib/lnrpc/client.rb
  12. 1967
      lib/lnrpc/rpc.proto
  13. 726
      lib/lnrpc/rpc_pb.rb
  14. 307
      lib/lnrpc/rpc_services_pb.rb
  15. 3
      lib/lnrpc/version.rb
  16. 31
      lnrpc.gemspec
  17. 5
      spec/lnrpc_spec.rb
  18. 14
      spec/spec_helper.rb

13
.gitignore vendored

@ -0,0 +1,13 @@
/.bundle/
/.yardoc
/_yardoc/
/coverage/
/doc/
/pkg/
/spec/reports/
/tmp/
# rspec failure tracking
.rspec_status
.ruby-version

3
.rspec

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

6
Gemfile

@ -0,0 +1,6 @@
source "https://rubygems.org"
git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
# Specify your gem's dependencies in lnrpc.gemspec
gemspec

42
Gemfile.lock

@ -0,0 +1,42 @@
PATH
remote: .
specs:
lnrpc (0.1.0)
grpc (>= 1.16.0)
GEM
remote: https://rubygems.org/
specs:
diff-lcs (1.3)
google-protobuf (3.6.1)
googleapis-common-protos-types (1.0.3)
google-protobuf (~> 3.0)
grpc (1.18.0)
google-protobuf (~> 3.1)
googleapis-common-protos-types (~> 1.0.0)
rake (10.5.0)
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)
PLATFORMS
ruby
DEPENDENCIES
bundler (~> 1.17)
lnrpc!
rake (~> 10.0)
rspec (~> 3.0)
BUNDLED WITH
1.17.2

21
LICENSE.txt

@ -0,0 +1,21 @@
The MIT License (MIT)
Copyright (c) 2019 Michael Bumann
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.

39
README.md

@ -0,0 +1,39 @@
# Lnrpc
Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/lnrpc`. To experiment with that code, run `bin/console` for an interactive prompt.
TODO: Delete this and the text above, and describe your gem
## Installation
Add this line to your application's Gemfile:
```ruby
gem 'lnrpc'
```
And then execute:
$ bundle
Or install it yourself as:
$ gem install lnrpc
## Usage
TODO: Write usage instructions here
## Development
After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
## Contributing
Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/lnrpc.
## License
The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

6
Rakefile

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

14
bin/console

@ -0,0 +1,14 @@
#!/usr/bin/env ruby
require "bundler/setup"
require "lnrpc"
# You can add fixtures and/or initialization code here to make experimenting
# with your gem easier. You can also use a different console, if you like.
# (If you use this, don't forget to add pry to your Gemfile!)
# require "pry"
# Pry.start
require "irb"
IRB.start(__FILE__)

8
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

8
lib/lnrpc.rb

@ -0,0 +1,8 @@
require "lnrpc/version"
module Lnrpc
class Error < StandardError; end
autoload :WalletUnlocker, 'lnrpc/rpc_services_pb'
autoload :Lightning, 'lnrpc/rpc_services_pb'
autoload :Client, 'lnrpc/client'
end

35
lib/lnrpc/client.rb

@ -0,0 +1,35 @@
module Lnrpc
class Client
attr_accessor :address, :credentials, :macaroon, :grpc_client
DEFAULT_ADDRESS = 'localhost:10009'
DEFAULT_CREDENTIALS_PATH = "~/.lnd/tls.cert"
DEFAULT_MACAROON_PATH = "~/.lnd/data/chain/bitcoin/testnet/admin.macaroon"
def initialize(options)
self.address = options[:address] || DEFAULT_ADDRESS
options[:credentials] ||= ::File.read(::File.expand_path(options[:credentials_path] || DEFAULT_CREDENTIALS_PATH))
self.credentials = options[:credentials]
options[:macaroon] ||= begin
macaroon_binary = ::File.read(::File.expand_path(options[:macaroon_path] || DEFAULT_MACAROON_PATH))
macaroon_binary.each_byte.map { |b| b.to_s(16).rjust(2,'0') }.join
end
self.macaroon = options[:macaroon]
self.grpc_client = Lnrpc::Lightning::Stub.new(self.address, GRPC::Core::ChannelCredentials.new(self.credentials))
end
def method_missing(m, *args, &block)
if args.last.is_a?(Hash)
args[-1][:metadata] ||= {}
args[-1][:metadata].merge!(macaroon: self.macaroon)
else
args.push({metadata: { macaroon: self.macaroon }})
end
self.grpc_client.send(m, *args)
end
end
end

1967
lib/lnrpc/rpc.proto

File diff suppressed because it is too large Load Diff

726
lib/lnrpc/rpc_pb.rb

@ -0,0 +1,726 @@
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: rpc.proto
require 'google/protobuf'
require 'google/api/annotations_pb'
Google::Protobuf::DescriptorPool.generated_pool.build do
add_message "lnrpc.GenSeedRequest" do
optional :aezeed_passphrase, :bytes, 1
optional :seed_entropy, :bytes, 2
end
add_message "lnrpc.GenSeedResponse" do
repeated :cipher_seed_mnemonic, :string, 1
optional :enciphered_seed, :bytes, 2
end
add_message "lnrpc.InitWalletRequest" do
optional :wallet_password, :bytes, 1
repeated :cipher_seed_mnemonic, :string, 2
optional :aezeed_passphrase, :bytes, 3
optional :recovery_window, :int32, 4
end
add_message "lnrpc.InitWalletResponse" do
end
add_message "lnrpc.UnlockWalletRequest" do
optional :wallet_password, :bytes, 1
optional :recovery_window, :int32, 2
end
add_message "lnrpc.UnlockWalletResponse" do
end
add_message "lnrpc.ChangePasswordRequest" do
optional :current_password, :bytes, 1
optional :new_password, :bytes, 2
end
add_message "lnrpc.ChangePasswordResponse" do
end
add_message "lnrpc.Transaction" do
optional :tx_hash, :string, 1
optional :amount, :int64, 2
optional :num_confirmations, :int32, 3
optional :block_hash, :string, 4
optional :block_height, :int32, 5
optional :time_stamp, :int64, 6
optional :total_fees, :int64, 7
repeated :dest_addresses, :string, 8
end
add_message "lnrpc.GetTransactionsRequest" do
end
add_message "lnrpc.TransactionDetails" do
repeated :transactions, :message, 1, "lnrpc.Transaction"
end
add_message "lnrpc.FeeLimit" do
oneof :limit do
optional :fixed, :int64, 1
optional :percent, :int64, 2
end
end
add_message "lnrpc.SendRequest" do
optional :dest, :bytes, 1
optional :dest_string, :string, 2
optional :amt, :int64, 3
optional :payment_hash, :bytes, 4
optional :payment_hash_string, :string, 5
optional :payment_request, :string, 6
optional :final_cltv_delta, :int32, 7
optional :fee_limit, :message, 8, "lnrpc.FeeLimit"
end
add_message "lnrpc.SendResponse" do
optional :payment_error, :string, 1
optional :payment_preimage, :bytes, 2
optional :payment_route, :message, 3, "lnrpc.Route"
end
add_message "lnrpc.SendToRouteRequest" do
optional :payment_hash, :bytes, 1
optional :payment_hash_string, :string, 2
repeated :routes, :message, 3, "lnrpc.Route"
end
add_message "lnrpc.ChannelPoint" do
optional :output_index, :uint32, 3
oneof :funding_txid do
optional :funding_txid_bytes, :bytes, 1
optional :funding_txid_str, :string, 2
end
end
add_message "lnrpc.LightningAddress" do
optional :pubkey, :string, 1
optional :host, :string, 2
end
add_message "lnrpc.SendManyRequest" do
map :AddrToAmount, :string, :int64, 1
optional :target_conf, :int32, 3
optional :sat_per_byte, :int64, 5
end
add_message "lnrpc.SendManyResponse" do
optional :txid, :string, 1
end
add_message "lnrpc.SendCoinsRequest" do
optional :addr, :string, 1
optional :amount, :int64, 2
optional :target_conf, :int32, 3
optional :sat_per_byte, :int64, 5
end
add_message "lnrpc.SendCoinsResponse" do
optional :txid, :string, 1
end
add_message "lnrpc.NewAddressRequest" do
optional :type, :enum, 1, "lnrpc.NewAddressRequest.AddressType"
end
add_enum "lnrpc.NewAddressRequest.AddressType" do
value :WITNESS_PUBKEY_HASH, 0
value :NESTED_PUBKEY_HASH, 1
end
add_message "lnrpc.NewAddressResponse" do
optional :address, :string, 1
end
add_message "lnrpc.SignMessageRequest" do
optional :msg, :bytes, 1
end
add_message "lnrpc.SignMessageResponse" do
optional :signature, :string, 1
end
add_message "lnrpc.VerifyMessageRequest" do
optional :msg, :bytes, 1
optional :signature, :string, 2
end
add_message "lnrpc.VerifyMessageResponse" do
optional :valid, :bool, 1
optional :pubkey, :string, 2
end
add_message "lnrpc.ConnectPeerRequest" do
optional :addr, :message, 1, "lnrpc.LightningAddress"
optional :perm, :bool, 2
end
add_message "lnrpc.ConnectPeerResponse" do
end
add_message "lnrpc.DisconnectPeerRequest" do
optional :pub_key, :string, 1
end
add_message "lnrpc.DisconnectPeerResponse" do
end
add_message "lnrpc.HTLC" do
optional :incoming, :bool, 1
optional :amount, :int64, 2
optional :hash_lock, :bytes, 3
optional :expiration_height, :uint32, 4
end
add_message "lnrpc.Channel" do
optional :active, :bool, 1
optional :remote_pubkey, :string, 2
optional :channel_point, :string, 3
optional :chan_id, :uint64, 4
optional :capacity, :int64, 5
optional :local_balance, :int64, 6
optional :remote_balance, :int64, 7
optional :commit_fee, :int64, 8
optional :commit_weight, :int64, 9
optional :fee_per_kw, :int64, 10
optional :unsettled_balance, :int64, 11
optional :total_satoshis_sent, :int64, 12
optional :total_satoshis_received, :int64, 13
optional :num_updates, :uint64, 14
repeated :pending_htlcs, :message, 15, "lnrpc.HTLC"
optional :csv_delay, :uint32, 16
optional :private, :bool, 17
end
add_message "lnrpc.ListChannelsRequest" do
optional :active_only, :bool, 1
optional :inactive_only, :bool, 2
optional :public_only, :bool, 3
optional :private_only, :bool, 4
end
add_message "lnrpc.ListChannelsResponse" do
repeated :channels, :message, 11, "lnrpc.Channel"
end
add_message "lnrpc.ChannelCloseSummary" do
optional :channel_point, :string, 1
optional :chan_id, :uint64, 2
optional :chain_hash, :string, 3
optional :closing_tx_hash, :string, 4
optional :remote_pubkey, :string, 5
optional :capacity, :int64, 6
optional :close_height, :uint32, 7
optional :settled_balance, :int64, 8
optional :time_locked_balance, :int64, 9
optional :close_type, :enum, 10, "lnrpc.ChannelCloseSummary.ClosureType"
end
add_enum "lnrpc.ChannelCloseSummary.ClosureType" do
value :COOPERATIVE_CLOSE, 0
value :LOCAL_FORCE_CLOSE, 1
value :REMOTE_FORCE_CLOSE, 2
value :BREACH_CLOSE, 3
value :FUNDING_CANCELED, 4
value :ABANDONED, 5
end
add_message "lnrpc.ClosedChannelsRequest" do
optional :cooperative, :bool, 1
optional :local_force, :bool, 2
optional :remote_force, :bool, 3
optional :breach, :bool, 4
optional :funding_canceled, :bool, 5
optional :abandoned, :bool, 6
end
add_message "lnrpc.ClosedChannelsResponse" do
repeated :channels, :message, 1, "lnrpc.ChannelCloseSummary"
end
add_message "lnrpc.Peer" do
optional :pub_key, :string, 1
optional :address, :string, 3
optional :bytes_sent, :uint64, 4
optional :bytes_recv, :uint64, 5
optional :sat_sent, :int64, 6
optional :sat_recv, :int64, 7
optional :inbound, :bool, 8
optional :ping_time, :int64, 9
end
add_message "lnrpc.ListPeersRequest" do
end
add_message "lnrpc.ListPeersResponse" do
repeated :peers, :message, 1, "lnrpc.Peer"
end
add_message "lnrpc.GetInfoRequest" do
end
add_message "lnrpc.GetInfoResponse" do
optional :identity_pubkey, :string, 1
optional :alias, :string, 2
optional :num_pending_channels, :uint32, 3
optional :num_active_channels, :uint32, 4
optional :num_peers, :uint32, 5
optional :block_height, :uint32, 6
optional :block_hash, :string, 8
optional :synced_to_chain, :bool, 9
optional :testnet, :bool, 10
repeated :chains, :string, 11
repeated :uris, :string, 12
optional :best_header_timestamp, :int64, 13
optional :version, :string, 14
end
add_message "lnrpc.ConfirmationUpdate" do
optional :block_sha, :bytes, 1
optional :block_height, :int32, 2
optional :num_confs_left, :uint32, 3
end
add_message "lnrpc.ChannelOpenUpdate" do
optional :channel_point, :message, 1, "lnrpc.ChannelPoint"
end
add_message "lnrpc.ChannelCloseUpdate" do
optional :closing_txid, :bytes, 1
optional :success, :bool, 2
end
add_message "lnrpc.CloseChannelRequest" do
optional :channel_point, :message, 1, "lnrpc.ChannelPoint"
optional :force, :bool, 2
optional :target_conf, :int32, 3
optional :sat_per_byte, :int64, 4
end
add_message "lnrpc.CloseStatusUpdate" do
oneof :update do
optional :close_pending, :message, 1, "lnrpc.PendingUpdate"
optional :confirmation, :message, 2, "lnrpc.ConfirmationUpdate"
optional :chan_close, :message, 3, "lnrpc.ChannelCloseUpdate"
end
end
add_message "lnrpc.PendingUpdate" do
optional :txid, :bytes, 1
optional :output_index, :uint32, 2
end
add_message "lnrpc.OpenChannelRequest" do
optional :node_pubkey, :bytes, 2
optional :node_pubkey_string, :string, 3
optional :local_funding_amount, :int64, 4
optional :push_sat, :int64, 5
optional :target_conf, :int32, 6
optional :sat_per_byte, :int64, 7
optional :private, :bool, 8
optional :min_htlc_msat, :int64, 9
optional :remote_csv_delay, :uint32, 10
optional :min_confs, :int32, 11
optional :spend_unconfirmed, :bool, 12
end
add_message "lnrpc.OpenStatusUpdate" do
oneof :update do
optional :chan_pending, :message, 1, "lnrpc.PendingUpdate"
optional :confirmation, :message, 2, "lnrpc.ConfirmationUpdate"
optional :chan_open, :message, 3, "lnrpc.ChannelOpenUpdate"
end
end
add_message "lnrpc.PendingHTLC" do
optional :incoming, :bool, 1
optional :amount, :int64, 2
optional :outpoint, :string, 3
optional :maturity_height, :uint32, 4
optional :blocks_til_maturity, :int32, 5
optional :stage, :uint32, 6
end
add_message "lnrpc.PendingChannelsRequest" do
end
add_message "lnrpc.PendingChannelsResponse" do
optional :total_limbo_balance, :int64, 1
repeated :pending_open_channels, :message, 2, "lnrpc.PendingChannelsResponse.PendingOpenChannel"
repeated :pending_closing_channels, :message, 3, "lnrpc.PendingChannelsResponse.ClosedChannel"
repeated :pending_force_closing_channels, :message, 4, "lnrpc.PendingChannelsResponse.ForceClosedChannel"
repeated :waiting_close_channels, :message, 5, "lnrpc.PendingChannelsResponse.WaitingCloseChannel"
end
add_message "lnrpc.PendingChannelsResponse.PendingChannel" do
optional :remote_node_pub, :string, 1
optional :channel_point, :string, 2
optional :capacity, :int64, 3
optional :local_balance, :int64, 4
optional :remote_balance, :int64, 5
end
add_message "lnrpc.PendingChannelsResponse.PendingOpenChannel" do
optional :channel, :message, 1, "lnrpc.PendingChannelsResponse.PendingChannel"
optional :confirmation_height, :uint32, 2
optional :commit_fee, :int64, 4
optional :commit_weight, :int64, 5
optional :fee_per_kw, :int64, 6
end
add_message "lnrpc.PendingChannelsResponse.WaitingCloseChannel" do
optional :channel, :message, 1, "lnrpc.PendingChannelsResponse.PendingChannel"
optional :limbo_balance, :int64, 2
end
add_message "lnrpc.PendingChannelsResponse.ClosedChannel" do
optional :channel, :message, 1, "lnrpc.PendingChannelsResponse.PendingChannel"
optional :closing_txid, :string, 2
end
add_message "lnrpc.PendingChannelsResponse.ForceClosedChannel" do
optional :channel, :message, 1, "lnrpc.PendingChannelsResponse.PendingChannel"
optional :closing_txid, :string, 2
optional :limbo_balance, :int64, 3
optional :maturity_height, :uint32, 4
optional :blocks_til_maturity, :int32, 5
optional :recovered_balance, :int64, 6
repeated :pending_htlcs, :message, 8, "lnrpc.PendingHTLC"
end
add_message "lnrpc.WalletBalanceRequest" do
end
add_message "lnrpc.WalletBalanceResponse" do
optional :total_balance, :int64, 1
optional :confirmed_balance, :int64, 2
optional :unconfirmed_balance, :int64, 3
end
add_message "lnrpc.ChannelBalanceRequest" do
end
add_message "lnrpc.ChannelBalanceResponse" do
optional :balance, :int64, 1
optional :pending_open_balance, :int64, 2
end
add_message "lnrpc.QueryRoutesRequest" do
optional :pub_key, :string, 1
optional :amt, :int64, 2
optional :num_routes, :int32, 3
optional :final_cltv_delta, :int32, 4
optional :fee_limit, :message, 5, "lnrpc.FeeLimit"
end
add_message "lnrpc.QueryRoutesResponse" do
repeated :routes, :message, 1, "lnrpc.Route"
end
add_message "lnrpc.Hop" do
optional :chan_id, :uint64, 1
optional :chan_capacity, :int64, 2
optional :amt_to_forward, :int64, 3
optional :fee, :int64, 4
optional :expiry, :uint32, 5
optional :amt_to_forward_msat, :int64, 6
optional :fee_msat, :int64, 7
end
add_message "lnrpc.Route" do
optional :total_time_lock, :uint32, 1
optional :total_fees, :int64, 2
optional :total_amt, :int64, 3
repeated :hops, :message, 4, "lnrpc.Hop"
optional :total_fees_msat, :int64, 5
optional :total_amt_msat, :int64, 6
end
add_message "lnrpc.NodeInfoRequest" do
optional :pub_key, :string, 1
end
add_message "lnrpc.NodeInfo" do
optional :node, :message, 1, "lnrpc.LightningNode"
optional :num_channels, :uint32, 2
optional :total_capacity, :int64, 3
end
add_message "lnrpc.LightningNode" do
optional :last_update, :uint32, 1
optional :pub_key, :string, 2
optional :alias, :string, 3
repeated :addresses, :message, 4, "lnrpc.NodeAddress"
optional :color, :string, 5
end
add_message "lnrpc.NodeAddress" do
optional :network, :string, 1
optional :addr, :string, 2
end
add_message "lnrpc.RoutingPolicy" do
optional :time_lock_delta, :uint32, 1
optional :min_htlc, :int64, 2
optional :fee_base_msat, :int64, 3
optional :fee_rate_milli_msat, :int64, 4
optional :disabled, :bool, 5
end
add_message "lnrpc.ChannelEdge" do
optional :channel_id, :uint64, 1
optional :chan_point, :string, 2
optional :last_update, :uint32, 3
optional :node1_pub, :string, 4
optional :node2_pub, :string, 5
optional :capacity, :int64, 6
optional :node1_policy, :message, 7, "lnrpc.RoutingPolicy"
optional :node2_policy, :message, 8, "lnrpc.RoutingPolicy"
end
add_message "lnrpc.ChannelGraphRequest" do
optional :include_unannounced, :bool, 1
end
add_message "lnrpc.ChannelGraph" do
repeated :nodes, :message, 1, "lnrpc.LightningNode"
repeated :edges, :message, 2, "lnrpc.ChannelEdge"
end
add_message "lnrpc.ChanInfoRequest" do
optional :chan_id, :uint64, 1
end
add_message "lnrpc.NetworkInfoRequest" do
end
add_message "lnrpc.NetworkInfo" do
optional :graph_diameter, :uint32, 1
optional :avg_out_degree, :double, 2
optional :max_out_degree, :uint32, 3
optional :num_nodes, :uint32, 4
optional :num_channels, :uint32, 5
optional :total_network_capacity, :int64, 6
optional :avg_channel_size, :double, 7
optional :min_channel_size, :int64, 8
optional :max_channel_size, :int64, 9
end
add_message "lnrpc.StopRequest" do
end
add_message "lnrpc.StopResponse" do
end
add_message "lnrpc.GraphTopologySubscription" do
end
add_message "lnrpc.GraphTopologyUpdate" do
repeated :node_updates, :message, 1, "lnrpc.NodeUpdate"
repeated :channel_updates, :message, 2, "lnrpc.ChannelEdgeUpdate"
repeated :closed_chans, :message, 3, "lnrpc.ClosedChannelUpdate"
end
add_message "lnrpc.NodeUpdate" do
repeated :addresses, :string, 1
optional :identity_key, :string, 2
optional :global_features, :bytes, 3
optional :alias, :string, 4
end
add_message "lnrpc.ChannelEdgeUpdate" do
optional :chan_id, :uint64, 1
optional :chan_point, :message, 2, "lnrpc.ChannelPoint"
optional :capacity, :int64, 3
optional :routing_policy, :message, 4, "lnrpc.RoutingPolicy"
optional :advertising_node, :string, 5
optional :connecting_node, :string, 6
end
add_message "lnrpc.ClosedChannelUpdate" do
optional :chan_id, :uint64, 1
optional :capacity, :int64, 2
optional :closed_height, :uint32, 3
optional :chan_point, :message, 4, "lnrpc.ChannelPoint"
end
add_message "lnrpc.HopHint" do
optional :node_id, :string, 1
optional :chan_id, :uint64, 2
optional :fee_base_msat, :uint32, 3
optional :fee_proportional_millionths, :uint32, 4
optional :cltv_expiry_delta, :uint32, 5
end
add_message "lnrpc.RouteHint" do
repeated :hop_hints, :message, 1, "lnrpc.HopHint"
end
add_message "lnrpc.Invoice" do
optional :memo, :string, 1
optional :receipt, :bytes, 2
optional :r_preimage, :bytes, 3
optional :r_hash, :bytes, 4
optional :value, :int64, 5
optional :settled, :bool, 6
optional :creation_date, :int64, 7
optional :settle_date, :int64, 8
optional :payment_request, :string, 9
optional :description_hash, :bytes, 10
optional :expiry, :int64, 11
optional :fallback_addr, :string, 12
optional :cltv_expiry, :uint64, 13
repeated :route_hints, :message, 14, "lnrpc.RouteHint"
optional :private, :bool, 15
optional :add_index, :uint64, 16
optional :settle_index, :uint64, 17
optional :amt_paid, :int64, 18
optional :amt_paid_sat, :int64, 19
optional :amt_paid_msat, :int64, 20
end
add_message "lnrpc.AddInvoiceResponse" do
optional :r_hash, :bytes, 1
optional :payment_request, :string, 2
optional :add_index, :uint64, 16
end
add_message "lnrpc.PaymentHash" do
optional :r_hash_str, :string, 1
optional :r_hash, :bytes, 2
end
add_message "lnrpc.ListInvoiceRequest" do
optional :pending_only, :bool, 1
optional :index_offset, :uint64, 4
optional :num_max_invoices, :uint64, 5
optional :reversed, :bool, 6
end
add_message "lnrpc.ListInvoiceResponse" do
repeated :invoices, :message, 1, "lnrpc.Invoice"
optional :last_index_offset, :uint64, 2
optional :first_index_offset, :uint64, 3
end
add_message "lnrpc.InvoiceSubscription" do
optional :add_index, :uint64, 1
optional :settle_index, :uint64, 2
end
add_message "lnrpc.Payment" do
optional :payment_hash, :string, 1
optional :value, :int64, 2
optional :creation_date, :int64, 3
repeated :path, :string, 4
optional :fee, :int64, 5
optional :payment_preimage, :string, 6
optional :value_sat, :int64, 7
optional :value_msat, :int64, 8
end
add_message "lnrpc.ListPaymentsRequest" do
end
add_message "lnrpc.ListPaymentsResponse" do
repeated :payments, :message, 1, "lnrpc.Payment"
end
add_message "lnrpc.DeleteAllPaymentsRequest" do
end
add_message "lnrpc.DeleteAllPaymentsResponse" do
end
add_message "lnrpc.AbandonChannelRequest" do
optional :channel_point, :message, 1, "lnrpc.ChannelPoint"
end
add_message "lnrpc.AbandonChannelResponse" do
end
add_message "lnrpc.DebugLevelRequest" do
optional :show, :bool, 1
optional :level_spec, :string, 2
end
add_message "lnrpc.DebugLevelResponse" do
optional :sub_systems, :string, 1
end
add_message "lnrpc.PayReqString" do
optional :pay_req, :string, 1
end
add_message "lnrpc.PayReq" do
optional :destination, :string, 1
optional :payment_hash, :string, 2
optional :num_satoshis, :int64, 3
optional :timestamp, :int64, 4
optional :expiry, :int64, 5
optional :description, :string, 6
optional :description_hash, :string, 7
optional :fallback_addr, :string, 8
optional :cltv_expiry, :int64, 9
repeated :route_hints, :message, 10, "lnrpc.RouteHint"
end
add_message "lnrpc.FeeReportRequest" do
end
add_message "lnrpc.ChannelFeeReport" do
optional :chan_point, :string, 1
optional :base_fee_msat, :int64, 2
optional :fee_per_mil, :int64, 3
optional :fee_rate, :double, 4
end
add_message "lnrpc.FeeReportResponse" do
repeated :channel_fees, :message, 1, "lnrpc.ChannelFeeReport"
optional :day_fee_sum, :uint64, 2
optional :week_fee_sum, :uint64, 3
optional :month_fee_sum, :uint64, 4
end
add_message "lnrpc.PolicyUpdateRequest" do
optional :base_fee_msat, :int64, 3
optional :fee_rate, :double, 4
optional :time_lock_delta, :uint32, 5
oneof :scope do
optional :global, :bool, 1
optional :chan_point, :message, 2, "lnrpc.ChannelPoint"
end
end
add_message "lnrpc.PolicyUpdateResponse" do
end
add_message "lnrpc.ForwardingHistoryRequest" do
optional :start_time, :uint64, 1
optional :end_time, :uint64, 2
optional :index_offset, :uint32, 3
optional :num_max_events, :uint32, 4
end
add_message "lnrpc.ForwardingEvent" do
optional :timestamp, :uint64, 1
optional :chan_id_in, :uint64, 2
optional :chan_id_out, :uint64, 4
optional :amt_in, :uint64, 5
optional :amt_out, :uint64, 6
optional :fee, :uint64, 7
end
add_message "lnrpc.ForwardingHistoryResponse" do
repeated :forwarding_events, :message, 1, "lnrpc.ForwardingEvent"
optional :last_offset_index, :uint32, 2
end
end
module Lnrpc
GenSeedRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.GenSeedRequest").msgclass
GenSeedResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.GenSeedResponse").msgclass
InitWalletRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.InitWalletRequest").msgclass
InitWalletResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.InitWalletResponse").msgclass
UnlockWalletRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.UnlockWalletRequest").msgclass
UnlockWalletResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.UnlockWalletResponse").msgclass
ChangePasswordRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ChangePasswordRequest").msgclass
ChangePasswordResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ChangePasswordResponse").msgclass
Transaction = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.Transaction").msgclass
GetTransactionsRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.GetTransactionsRequest").msgclass
TransactionDetails = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.TransactionDetails").msgclass
FeeLimit = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.FeeLimit").msgclass
SendRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.SendRequest").msgclass
SendResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.SendResponse").msgclass
SendToRouteRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.SendToRouteRequest").msgclass
ChannelPoint = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ChannelPoint").msgclass
LightningAddress = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.LightningAddress").msgclass
SendManyRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.SendManyRequest").msgclass
SendManyResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.SendManyResponse").msgclass
SendCoinsRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.SendCoinsRequest").msgclass
SendCoinsResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.SendCoinsResponse").msgclass
NewAddressRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.NewAddressRequest").msgclass
NewAddressRequest::AddressType = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.NewAddressRequest.AddressType").enummodule
NewAddressResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.NewAddressResponse").msgclass
SignMessageRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.SignMessageRequest").msgclass
SignMessageResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.SignMessageResponse").msgclass
VerifyMessageRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.VerifyMessageRequest").msgclass
VerifyMessageResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.VerifyMessageResponse").msgclass
ConnectPeerRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ConnectPeerRequest").msgclass
ConnectPeerResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ConnectPeerResponse").msgclass
DisconnectPeerRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.DisconnectPeerRequest").msgclass
DisconnectPeerResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.DisconnectPeerResponse").msgclass
HTLC = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.HTLC").msgclass
Channel = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.Channel").msgclass
ListChannelsRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ListChannelsRequest").msgclass
ListChannelsResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ListChannelsResponse").msgclass
ChannelCloseSummary = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ChannelCloseSummary").msgclass
ChannelCloseSummary::ClosureType = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ChannelCloseSummary.ClosureType").enummodule
ClosedChannelsRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ClosedChannelsRequest").msgclass
ClosedChannelsResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ClosedChannelsResponse").msgclass
Peer = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.Peer").msgclass
ListPeersRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ListPeersRequest").msgclass
ListPeersResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ListPeersResponse").msgclass
GetInfoRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.GetInfoRequest").msgclass
GetInfoResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.GetInfoResponse").msgclass
ConfirmationUpdate = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ConfirmationUpdate").msgclass
ChannelOpenUpdate = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ChannelOpenUpdate").msgclass
ChannelCloseUpdate = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ChannelCloseUpdate").msgclass
CloseChannelRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.CloseChannelRequest").msgclass
CloseStatusUpdate = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.CloseStatusUpdate").msgclass
PendingUpdate = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.PendingUpdate").msgclass
OpenChannelRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.OpenChannelRequest").msgclass
OpenStatusUpdate = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.OpenStatusUpdate").msgclass
PendingHTLC = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.PendingHTLC").msgclass
PendingChannelsRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.PendingChannelsRequest").msgclass
PendingChannelsResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.PendingChannelsResponse").msgclass
PendingChannelsResponse::PendingChannel = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.PendingChannelsResponse.PendingChannel").msgclass
PendingChannelsResponse::PendingOpenChannel = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.PendingChannelsResponse.PendingOpenChannel").msgclass
PendingChannelsResponse::WaitingCloseChannel = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.PendingChannelsResponse.WaitingCloseChannel").msgclass
PendingChannelsResponse::ClosedChannel = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.PendingChannelsResponse.ClosedChannel").msgclass
PendingChannelsResponse::ForceClosedChannel = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.PendingChannelsResponse.ForceClosedChannel").msgclass
WalletBalanceRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.WalletBalanceRequest").msgclass
WalletBalanceResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.WalletBalanceResponse").msgclass
ChannelBalanceRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ChannelBalanceRequest").msgclass
ChannelBalanceResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ChannelBalanceResponse").msgclass
QueryRoutesRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.QueryRoutesRequest").msgclass
QueryRoutesResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.QueryRoutesResponse").msgclass
Hop = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.Hop").msgclass
Route = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.Route").msgclass
NodeInfoRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.NodeInfoRequest").msgclass
NodeInfo = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.NodeInfo").msgclass
LightningNode = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.LightningNode").msgclass
NodeAddress = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.NodeAddress").msgclass
RoutingPolicy = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.RoutingPolicy").msgclass
ChannelEdge = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ChannelEdge").msgclass
ChannelGraphRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ChannelGraphRequest").msgclass
ChannelGraph = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ChannelGraph").msgclass
ChanInfoRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ChanInfoRequest").msgclass
NetworkInfoRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.NetworkInfoRequest").msgclass
NetworkInfo = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.NetworkInfo").msgclass
StopRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.StopRequest").msgclass
StopResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.StopResponse").msgclass
GraphTopologySubscription = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.GraphTopologySubscription").msgclass
GraphTopologyUpdate = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.GraphTopologyUpdate").msgclass
NodeUpdate = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.NodeUpdate").msgclass
ChannelEdgeUpdate = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ChannelEdgeUpdate").msgclass
ClosedChannelUpdate = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ClosedChannelUpdate").msgclass
HopHint = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.HopHint").msgclass
RouteHint = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.RouteHint").msgclass
Invoice = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.Invoice").msgclass
AddInvoiceResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.AddInvoiceResponse").msgclass
PaymentHash = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.PaymentHash").msgclass
ListInvoiceRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ListInvoiceRequest").msgclass
ListInvoiceResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ListInvoiceResponse").msgclass
InvoiceSubscription = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.InvoiceSubscription").msgclass
Payment = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.Payment").msgclass
ListPaymentsRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ListPaymentsRequest").msgclass
ListPaymentsResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ListPaymentsResponse").msgclass
DeleteAllPaymentsRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.DeleteAllPaymentsRequest").msgclass
DeleteAllPaymentsResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.DeleteAllPaymentsResponse").msgclass
AbandonChannelRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.AbandonChannelRequest").msgclass
AbandonChannelResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.AbandonChannelResponse").msgclass
DebugLevelRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.DebugLevelRequest").msgclass
DebugLevelResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.DebugLevelResponse").msgclass
PayReqString = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.PayReqString").msgclass
PayReq = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.PayReq").msgclass
FeeReportRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.FeeReportRequest").msgclass
ChannelFeeReport = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ChannelFeeReport").msgclass
FeeReportResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.FeeReportResponse").msgclass
PolicyUpdateRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.PolicyUpdateRequest").msgclass
PolicyUpdateResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.PolicyUpdateResponse").msgclass
ForwardingHistoryRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ForwardingHistoryRequest").msgclass
ForwardingEvent = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ForwardingEvent").msgclass
ForwardingHistoryResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("lnrpc.ForwardingHistoryResponse").msgclass
end

307
lib/lnrpc/rpc_services_pb.rb

@ -0,0 +1,307 @@
# Generated by the protocol buffer compiler. DO NOT EDIT!
# Source: rpc.proto for package 'lnrpc'
require 'grpc'
require_relative 'rpc_pb'
module Lnrpc
module WalletUnlocker
# The WalletUnlocker service is used to set up a wallet password for
# lnd at first startup, and unlock a previously set up wallet.
class Service
include GRPC::GenericService
self.marshal_class_method = :encode
self.unmarshal_class_method = :decode
self.service_name = 'lnrpc.WalletUnlocker'
# *
# GenSeed is the first method that should be used to instantiate a new lnd
# instance. This method allows a caller to generate a new aezeed cipher seed
# given an optional passphrase. If provided, the passphrase will be necessary
# to decrypt the cipherseed to expose the internal wallet seed.
#
# Once the cipherseed is obtained and verified by the user, the InitWallet
# method should be used to commit the newly generated seed, and create the
# wallet.
rpc :GenSeed, GenSeedRequest, GenSeedResponse
# *
# InitWallet is used when lnd is starting up for the first time to fully
# initialize the daemon and its internal wallet. At the very least a wallet
# password must be provided. This will be used to encrypt sensitive material
# on disk.
#
# In the case of a recovery scenario, the user can also specify their aezeed
# mnemonic and passphrase. If set, then the daemon will use this prior state
# to initialize its internal wallet.
#
# Alternatively, this can be used along with the GenSeed RPC to obtain a
# seed, then present it to the user. Once it has been verified by the user,
# the seed can be fed into this RPC in order to commit the new wallet.
rpc :InitWallet, InitWalletRequest, InitWalletResponse
# * lncli: `unlock`
# UnlockWallet is used at startup of lnd to provide a password to unlock
# the wallet database.
rpc :UnlockWallet, UnlockWalletRequest, UnlockWalletResponse
# * lncli: `changepassword`
# ChangePassword changes the password of the encrypted wallet. This will
# automatically unlock the wallet database if successful.
rpc :ChangePassword, ChangePasswordRequest, ChangePasswordResponse
end
Stub = Service.rpc_stub_class
end
module Lightning
class Service
include GRPC::GenericService
self.marshal_class_method = :encode
self.unmarshal_class_method = :decode
self.service_name = 'lnrpc.Lightning'
# * lncli: `walletbalance`
# WalletBalance returns total unspent outputs(confirmed and unconfirmed), all
# confirmed unspent outputs and all unconfirmed unspent outputs under control
# of the wallet.
rpc :WalletBalance, WalletBalanceRequest, WalletBalanceResponse
# * lncli: `channelbalance`
# ChannelBalance returns the total funds available across all open channels
# in satoshis.
rpc :ChannelBalance, ChannelBalanceRequest, ChannelBalanceResponse
# * lncli: `listchaintxns`
# GetTransactions returns a list describing all the known transactions
# relevant to the wallet.
rpc :GetTransactions, GetTransactionsRequest, TransactionDetails
# * lncli: `sendcoins`
# 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.
rpc :SendCoins, SendCoinsRequest, SendCoinsResponse
# *
# SubscribeTransactions creates a uni-directional stream from the server to
# the client in which any newly discovered transactions relevant to the
# wallet are sent over.
rpc :SubscribeTransactions, GetTransactionsRequest, stream(Transaction)
# * lncli: `sendmany`
# 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.
rpc :SendMany, SendManyRequest, SendManyResponse
# * lncli: `newaddress`
# NewAddress creates a new address under control of the local wallet.
rpc :NewAddress, NewAddressRequest, NewAddressResponse
# * lncli: `signmessage`
# SignMessage signs a message with this node's private key. The returned
# signature string is `zbase32` encoded and pubkey recoverable, meaning that
# only the message digest and signature are needed for verification.
rpc :SignMessage, SignMessageRequest, SignMessageResponse
# * lncli: `verifymessage`
# VerifyMessage verifies a signature over a msg. The signature must be
# zbase32 encoded and signed by an active node in the resident node's
# channel database. In addition to returning the validity of the signature,
# VerifyMessage also returns the recovered pubkey from the signature.
rpc :VerifyMessage, VerifyMessageRequest, VerifyMessageResponse
# * lncli: `connect`
# 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.
rpc :ConnectPeer, ConnectPeerRequest, ConnectPeerResponse
# * lncli: `disconnect`
# 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.
rpc :DisconnectPeer, DisconnectPeerRequest, DisconnectPeerResponse
# * lncli: `listpeers`
# ListPeers returns a verbose listing of all currently active peers.
rpc :ListPeers, ListPeersRequest, ListPeersResponse
# * lncli: `getinfo`
# 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.
rpc :GetInfo, GetInfoRequest, GetInfoResponse
# TODO(roasbeef): merge with below with bool?
#
# * lncli: `pendingchannels`
# 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.
rpc :PendingChannels, PendingChannelsRequest, PendingChannelsResponse
# * lncli: `listchannels`
# ListChannels returns a description of all the open channels that this node
# is a participant in.
rpc :ListChannels, ListChannelsRequest, ListChannelsResponse
# * lncli: `closedchannels`
# ClosedChannels returns a description of all the closed channels that
# this node was a participant in.
rpc :ClosedChannels, ClosedChannelsRequest, ClosedChannelsResponse
# *
# OpenChannelSync is a synchronous version of the OpenChannel RPC call. This
# call is meant to be consumed by clients to the REST proxy. As with all
# other sync calls, all byte slices are intended to be populated as hex
# encoded strings.
rpc :OpenChannelSync, OpenChannelRequest, ChannelPoint
# * lncli: `openchannel`
# 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.
rpc :OpenChannel, OpenChannelRequest, stream(OpenStatusUpdate)
# * lncli: `closechannel`
# 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.
rpc :CloseChannel, CloseChannelRequest, stream(CloseStatusUpdate)
# * lncli: `abandonchannel`
# 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.
rpc :AbandonChannel, AbandonChannelRequest, AbandonChannelResponse
# * lncli: `sendpayment`
# SendPayment dispatches a bi-directional streaming RPC for sending payments
# through the Lightning Network. A single RPC invocation creates a persistent
# bi-directional stream allowing clients to rapidly send payments through the
# Lightning Network with a single persistent connection.
rpc :SendPayment, stream(SendRequest), stream(SendResponse)
# *
# 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.
rpc :SendPaymentSync, SendRequest, SendResponse
# * lncli: `sendtoroute`
# SendToRoute is a bi-directional streaming RPC for sending payment through
# the Lightning Network. This method differs from SendPayment in that it
# allows users to specify a full route manually. This can be used for things
# like rebalancing, and atomic swaps.
rpc :SendToRoute, stream(SendToRouteRequest), stream(SendResponse)
# *
# SendToRouteSync is a synchronous version of SendToRoute. It Will block
# until the payment either fails or succeeds.
rpc :SendToRouteSync, SendToRouteRequest, SendResponse
# * lncli: `addinvoice`
# 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.
rpc :AddInvoice, Invoice, AddInvoiceResponse
# * lncli: `listinvoices`
# 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. The reversed flag is set by default in order to paginate
# backwards. If you wish to paginate forwards, you must explicitly set the
# flag to false. If none of the parameters are specified, then the last 100
# invoices will be returned.
rpc :ListInvoices, ListInvoiceRequest, ListInvoiceResponse
# * lncli: `lookupinvoice`
# 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.
rpc :LookupInvoice, PaymentHash, Invoice
# *
# SubscribeInvoices returns a uni-directional stream (server -> client) for
# notifying the client of newly added/settled invoices. The caller can
# optionally specify the add_index and/or the settle_index. If the add_index
# is specified, then we'll first start by sending add invoice events for all
# invoices with an add_index greater than the specified value. If the
# settle_index is specified, the next, we'll send out all settle events for
# invoices with a settle_index greater than the specified value. One or both
# of these fields can be set. If no fields are set, then we'll only send out
# the latest add/settle events.
rpc :SubscribeInvoices, InvoiceSubscription, stream(Invoice)
# * lncli: `decodepayreq`
# DecodePayReq takes an encoded payment request string and attempts to decode
# it, returning a full description of the conditions encoded within the
# payment request.
rpc :DecodePayReq, PayReqString, PayReq
# * lncli: `listpayments`
# ListPayments returns a list of all outgoing payments.
rpc :ListPayments, ListPaymentsRequest, ListPaymentsResponse
# *
# DeleteAllPayments deletes all outgoing payments from DB.
rpc :DeleteAllPayments, DeleteAllPaymentsRequest, DeleteAllPaymentsResponse
# * lncli: `describegraph`
# DescribeGraph returns a description of the latest graph state from the
# point of view of the node. The graph information is partitioned into two
# components: all the nodes/vertexes, and all the edges that connect the
# vertexes themselves. As this is a directed graph, the edges also contain
# the node directional specific routing policy which includes: the time lock
# delta, fee information, etc.
rpc :DescribeGraph, ChannelGraphRequest, ChannelGraph
# * lncli: `getchaninfo`
# 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.
rpc :GetChanInfo, ChanInfoRequest, ChannelEdge
# * lncli: `getnodeinfo`
# GetNodeInfo returns the latest advertised, aggregated, and authenticated
# channel information for the specified node identified by its public key.
rpc :GetNodeInfo, NodeInfoRequest, NodeInfo
# * lncli: `queryroutes`
# 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.
rpc :QueryRoutes, QueryRoutesRequest, QueryRoutesResponse
# * lncli: `getnetworkinfo`
# GetNetworkInfo returns some basic stats about the known channel graph from
# the point of view of the node.
rpc :GetNetworkInfo, NetworkInfoRequest, NetworkInfo
# * lncli: `stop`
# StopDaemon will send a shutdown request to the interrupt handler, triggering
# a graceful shutdown of the daemon.
rpc :StopDaemon, StopRequest, StopResponse
# *
# SubscribeChannelGraph launches a streaming RPC that allows the caller to
# receive notifications upon any changes to the channel graph topology from
# the point of view of the responding node. Events notified include: new
# nodes coming online, nodes updating their authenticated attributes, new
# channels being advertised, updates in the routing policy for a directional
# channel edge, and when channels are closed on-chain.
rpc :SubscribeChannelGraph, GraphTopologySubscription, stream(GraphTopologyUpdate)
# * lncli: `debuglevel`
# DebugLevel allows a caller to programmatically set the logging verbosity of
# lnd. The logging can be targeted according to a coarse daemon-wide logging
# level, or in a granular fashion to specify the logging for a target
# sub-system.
rpc :DebugLevel, DebugLevelRequest, DebugLevelResponse
# * lncli: `feereport`
# FeeReport allows the caller to obtain a report detailing the current fee
# schedule enforced by the node globally for each channel.
rpc :FeeReport, FeeReportRequest, FeeReportResponse
# * lncli: `updatechanpolicy`
# UpdateChannelPolicy allows the caller to update the fee schedule and
# channel policies for all channels globally, or a particular channel.
rpc :UpdateChannelPolicy, PolicyUpdateRequest, PolicyUpdateResponse
# * lncli: `fwdinghistory`
# ForwardingHistory allows the caller to query the htlcswitch for a record of
# all HTLC's forwarded within the target time range, and integer offset
# within that time range. If no time-range is specified, then the first chunk
# of the past 24 hrs of forwarding history are returned.
#
# A list of forwarding events are returned. The size of each forwarding event
# is 40 bytes, and the max message size able to be returned in gRPC is 4 MiB.
# As a result each message can only contain 50k entries. Each response has
# the index offset of the last entry. The index offset can be provided to the
# request to allow the caller to skip a series of records.
rpc :ForwardingHistory, ForwardingHistoryRequest, ForwardingHistoryResponse
end
Stub = Service.rpc_stub_class
end
end

3
lib/lnrpc/version.rb

@ -0,0 +1,3 @@
module Lnrpc
VERSION = "0.1.0"
end

31
lnrpc.gemspec

@ -0,0 +1,31 @@
lib = File.expand_path("../lib", __FILE__)
$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
require "lnrpc/version"
Gem::Specification.new do |spec|
spec.name = "lnrpc"
spec.version = Lnrpc::VERSION
spec.authors = ["Michael Bumann"]
spec.email = ["hello@michaelbumann.com"]
spec.summary = %q{gRPC interface for lnd packed as ruby gem}
spec.description = %q{gRPC service definitions for the Lightning Network Daemon (lnd) gRPC interace packed as ruby gem}
spec.homepage = "https://github.com/bumi/lnrpc"
spec.license = "MIT"
# Specify which files should be added to the gem when it is released.
# The `git ls-files -z` loads the files in the RubyGem that have been added into git.
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_development_dependency "bundler", "~> 1.17"
spec.add_development_dependency "rake", "~> 10.0"
spec.add_development_dependency "rspec", "~> 3.0"
spec.add_dependency "grpc", ">= 1.16.0"
end

5
spec/lnrpc_spec.rb

@ -0,0 +1,5 @@
RSpec.describe Lnrpc do
it "has a version number" do
expect(Lnrpc::VERSION).not_to be nil
end
end

14
spec/spec_helper.rb

@ -0,0 +1,14 @@
require "bundler/setup"
require "lnrpc"
RSpec.configure do |config|
# Enable flags like --only-failures and --next-failure
config.example_status_persistence_file_path = ".rspec_status"
# Disable RSpec exposing methods globally on `Module` and `main`
config.disable_monkey_patching!
config.expect_with :rspec do |c|
c.syntax = :expect
end
end
Loading…
Cancel
Save