Package net.osslabz.lnd.api

Class LightningApi

java.lang.Object
net.osslabz.lnd.api.LightningApi
public class LightningApi extends Object

  • Constructor Details

    • LightningApi

      public LightningApi()

    • LightningApi

      public LightningApi(ApiClient apiClient)

  • Method Details

    • getApiClient

      public ApiClient getApiClient()

    • setApiClient

      public void setApiClient(ApiClient apiClient)

    • getHostIndex

      public int getHostIndex()

    • setHostIndex

      public void setHostIndex(int hostIndex)

    • getCustomBaseUrl

      public String getCustomBaseUrl()

    • setCustomBaseUrl

      public void setCustomBaseUrl(String customBaseUrl)

    • abandonChannelCall

      public okhttp3.Call abandonChannelCall(String channelPointFundingTxidStr, Long channelPointOutputIndex, byte[] channelPointFundingTxidBytes, Boolean pendingFundingShimOnly, Boolean iKnowWhatIAmDoing, ApiCallback _callback) throws ApiException
      Build call for abandonChannel
      Parameters:
      channelPointFundingTxidStr - Hex-encoded string representing the byte-reversed hash of the funding transaction. (required)
      channelPointOutputIndex - The index of the output of the funding transaction (required)
      channelPointFundingTxidBytes - Txid of the funding transaction. When using REST, this field must be encoded as base64. (optional)
      pendingFundingShimOnly - (optional)
      iKnowWhatIAmDoing - Override the requirement for being in dev mode by setting this to true and confirming the user knows what they are doing and this is a potential foot gun to lose funds if used on active channels. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • abandonChannel

      public Object abandonChannel(String channelPointFundingTxidStr, Long channelPointOutputIndex, byte[] channelPointFundingTxidBytes, Boolean pendingFundingShimOnly, Boolean iKnowWhatIAmDoing) throws ApiException
      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. This method can also be used to remove externally funded channels where the funding transaction was never broadcast. Only available for non-externally funded channels in dev build.
      Parameters:
      channelPointFundingTxidStr - Hex-encoded string representing the byte-reversed hash of the funding transaction. (required)
      channelPointOutputIndex - The index of the output of the funding transaction (required)
      channelPointFundingTxidBytes - Txid of the funding transaction. When using REST, this field must be encoded as base64. (optional)
      pendingFundingShimOnly - (optional)
      iKnowWhatIAmDoing - Override the requirement for being in dev mode by setting this to true and confirming the user knows what they are doing and this is a potential foot gun to lose funds if used on active channels. (optional)
      Returns:
      Object
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • abandonChannelWithHttpInfo

      public ApiResponse<Object> abandonChannelWithHttpInfo(String channelPointFundingTxidStr, Long channelPointOutputIndex, byte[] channelPointFundingTxidBytes, Boolean pendingFundingShimOnly, Boolean iKnowWhatIAmDoing) throws ApiException
      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. This method can also be used to remove externally funded channels where the funding transaction was never broadcast. Only available for non-externally funded channels in dev build.
      Parameters:
      channelPointFundingTxidStr - Hex-encoded string representing the byte-reversed hash of the funding transaction. (required)
      channelPointOutputIndex - The index of the output of the funding transaction (required)
      channelPointFundingTxidBytes - Txid of the funding transaction. When using REST, this field must be encoded as base64. (optional)
      pendingFundingShimOnly - (optional)
      iKnowWhatIAmDoing - Override the requirement for being in dev mode by setting this to true and confirming the user knows what they are doing and this is a potential foot gun to lose funds if used on active channels. (optional)
      Returns:
      ApiResponse<Object>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • abandonChannelAsync

      public okhttp3.Call abandonChannelAsync(String channelPointFundingTxidStr, Long channelPointOutputIndex, byte[] channelPointFundingTxidBytes, Boolean pendingFundingShimOnly, Boolean iKnowWhatIAmDoing, ApiCallback<Object> _callback) throws ApiException
      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. This method can also be used to remove externally funded channels where the funding transaction was never broadcast. Only available for non-externally funded channels in dev build. (asynchronously)
      Parameters:
      channelPointFundingTxidStr - Hex-encoded string representing the byte-reversed hash of the funding transaction. (required)
      channelPointOutputIndex - The index of the output of the funding transaction (required)
      channelPointFundingTxidBytes - Txid of the funding transaction. When using REST, this field must be encoded as base64. (optional)
      pendingFundingShimOnly - (optional)
      iKnowWhatIAmDoing - Override the requirement for being in dev mode by setting this to true and confirming the user knows what they are doing and this is a potential foot gun to lose funds if used on active channels. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • addInvoiceCall

      public okhttp3.Call addInvoiceCall(LnrpcInvoice body, ApiCallback _callback) throws ApiException
      Build call for addInvoice
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • addInvoice

      public LnrpcAddInvoiceResponse addInvoice(LnrpcInvoice body) throws ApiException
      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.
      Parameters:
      body - (required)
      Returns:
      LnrpcAddInvoiceResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • addInvoiceWithHttpInfo

      public ApiResponse<LnrpcAddInvoiceResponse> addInvoiceWithHttpInfo(LnrpcInvoice body) throws ApiException
      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.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<LnrpcAddInvoiceResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • addInvoiceAsync

      public okhttp3.Call addInvoiceAsync(LnrpcInvoice body, ApiCallback<LnrpcAddInvoiceResponse> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • bakeMacaroonCall

      public okhttp3.Call bakeMacaroonCall(LnrpcBakeMacaroonRequest body, ApiCallback _callback) throws ApiException
      Build call for bakeMacaroon
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • bakeMacaroon

      public LnrpcBakeMacaroonResponse bakeMacaroon(LnrpcBakeMacaroonRequest body) throws ApiException
      lncli: `bakemacaroon` BakeMacaroon allows the creation of a new macaroon with custom read and write permissions. No first-party caveats are added since this can be done offline.
      Parameters:
      body - (required)
      Returns:
      LnrpcBakeMacaroonResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • bakeMacaroonWithHttpInfo

      public ApiResponse<LnrpcBakeMacaroonResponse> bakeMacaroonWithHttpInfo(LnrpcBakeMacaroonRequest body) throws ApiException
      lncli: `bakemacaroon` BakeMacaroon allows the creation of a new macaroon with custom read and write permissions. No first-party caveats are added since this can be done offline.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<LnrpcBakeMacaroonResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • bakeMacaroonAsync

      public okhttp3.Call bakeMacaroonAsync(LnrpcBakeMacaroonRequest body, ApiCallback<LnrpcBakeMacaroonResponse> _callback) throws ApiException
      lncli: `bakemacaroon` BakeMacaroon allows the creation of a new macaroon with custom read and write permissions. No first-party caveats are added since this can be done offline. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • batchOpenChannelCall

      public okhttp3.Call batchOpenChannelCall(LnrpcBatchOpenChannelRequest body, ApiCallback _callback) throws ApiException
      Build call for batchOpenChannel
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • batchOpenChannel

      public LnrpcBatchOpenChannelResponse batchOpenChannel(LnrpcBatchOpenChannelRequest body) throws ApiException
      lncli: `batchopenchannel` BatchOpenChannel attempts to open multiple single-funded channels in a single transaction in an atomic way. This means either all channel open requests succeed at once or all attempts are aborted if any of them fail. This is the safer variant of using PSBTs to manually fund a batch of channels through the OpenChannel RPC.
      Parameters:
      body - (required)
      Returns:
      LnrpcBatchOpenChannelResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • batchOpenChannelWithHttpInfo

      public ApiResponse<LnrpcBatchOpenChannelResponse> batchOpenChannelWithHttpInfo(LnrpcBatchOpenChannelRequest body) throws ApiException
      lncli: `batchopenchannel` BatchOpenChannel attempts to open multiple single-funded channels in a single transaction in an atomic way. This means either all channel open requests succeed at once or all attempts are aborted if any of them fail. This is the safer variant of using PSBTs to manually fund a batch of channels through the OpenChannel RPC.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<LnrpcBatchOpenChannelResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • batchOpenChannelAsync

      public okhttp3.Call batchOpenChannelAsync(LnrpcBatchOpenChannelRequest body, ApiCallback<LnrpcBatchOpenChannelResponse> _callback) throws ApiException
      lncli: `batchopenchannel` BatchOpenChannel attempts to open multiple single-funded channels in a single transaction in an atomic way. This means either all channel open requests succeed at once or all attempts are aborted if any of them fail. This is the safer variant of using PSBTs to manually fund a batch of channels through the OpenChannel RPC. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • channelAcceptorCall

      public okhttp3.Call channelAcceptorCall(LnrpcChannelAcceptResponse body, ApiCallback _callback) throws ApiException
      Build call for channelAcceptor
      Parameters:
      body - (streaming inputs) (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • channelAcceptor

      public StreamResultOfLnrpcChannelAcceptRequest channelAcceptor(LnrpcChannelAcceptResponse body) throws ApiException
      ChannelAcceptor dispatches a bi-directional streaming RPC in which OpenChannel requests are sent to the client and the client responds with a boolean that tells LND whether or not to accept the channel. This allows node operators to specify their own criteria for accepting inbound channels through a single persistent connection.
      Parameters:
      body - (streaming inputs) (required)
      Returns:
      StreamResultOfLnrpcChannelAcceptRequest
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • channelAcceptorWithHttpInfo

      public ApiResponse<StreamResultOfLnrpcChannelAcceptRequest> channelAcceptorWithHttpInfo(LnrpcChannelAcceptResponse body) throws ApiException
      ChannelAcceptor dispatches a bi-directional streaming RPC in which OpenChannel requests are sent to the client and the client responds with a boolean that tells LND whether or not to accept the channel. This allows node operators to specify their own criteria for accepting inbound channels through a single persistent connection.
      Parameters:
      body - (streaming inputs) (required)
      Returns:
      ApiResponse<StreamResultOfLnrpcChannelAcceptRequest>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • channelAcceptorAsync

      public okhttp3.Call channelAcceptorAsync(LnrpcChannelAcceptResponse body, ApiCallback<StreamResultOfLnrpcChannelAcceptRequest> _callback) throws ApiException
      ChannelAcceptor dispatches a bi-directional streaming RPC in which OpenChannel requests are sent to the client and the client responds with a boolean that tells LND whether or not to accept the channel. This allows node operators to specify their own criteria for accepting inbound channels through a single persistent connection. (asynchronously)
      Parameters:
      body - (streaming inputs) (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • channelBalanceCall

      public okhttp3.Call channelBalanceCall(ApiCallback _callback) throws ApiException
      Build call for channelBalance
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • channelBalance

      public LnrpcChannelBalanceResponse channelBalance() throws ApiException
      lncli: `channelbalance` ChannelBalance returns a report on the total funds across all open channels, categorized in local/remote, pending local/remote and unsettled local/remote balances.
      Returns:
      LnrpcChannelBalanceResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • channelBalanceWithHttpInfo

      public ApiResponse<LnrpcChannelBalanceResponse> channelBalanceWithHttpInfo() throws ApiException
      lncli: `channelbalance` ChannelBalance returns a report on the total funds across all open channels, categorized in local/remote, pending local/remote and unsettled local/remote balances.
      Returns:
      ApiResponse<LnrpcChannelBalanceResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • channelBalanceAsync

      public okhttp3.Call channelBalanceAsync(ApiCallback<LnrpcChannelBalanceResponse> _callback) throws ApiException
      lncli: `channelbalance` ChannelBalance returns a report on the total funds across all open channels, categorized in local/remote, pending local/remote and unsettled local/remote balances. (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • checkMacaroonPermissionsCall

      public okhttp3.Call checkMacaroonPermissionsCall(LnrpcCheckMacPermRequest body, ApiCallback _callback) throws ApiException
      Build call for checkMacaroonPermissions
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • checkMacaroonPermissions

      public LnrpcCheckMacPermResponse checkMacaroonPermissions(LnrpcCheckMacPermRequest body) throws ApiException
      CheckMacaroonPermissions checks whether a request follows the constraints imposed on the macaroon and that the macaroon is authorized to follow the provided permissions.
      Parameters:
      body - (required)
      Returns:
      LnrpcCheckMacPermResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • checkMacaroonPermissionsWithHttpInfo

      public ApiResponse<LnrpcCheckMacPermResponse> checkMacaroonPermissionsWithHttpInfo(LnrpcCheckMacPermRequest body) throws ApiException
      CheckMacaroonPermissions checks whether a request follows the constraints imposed on the macaroon and that the macaroon is authorized to follow the provided permissions.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<LnrpcCheckMacPermResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • checkMacaroonPermissionsAsync

      public okhttp3.Call checkMacaroonPermissionsAsync(LnrpcCheckMacPermRequest body, ApiCallback<LnrpcCheckMacPermResponse> _callback) throws ApiException
      CheckMacaroonPermissions checks whether a request follows the constraints imposed on the macaroon and that the macaroon is authorized to follow the provided permissions. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • closeChannelCall

      public okhttp3.Call closeChannelCall(String channelPointFundingTxidStr, Long channelPointOutputIndex, byte[] channelPointFundingTxidBytes, Boolean force, Integer targetConf, String satPerByte, String deliveryAddress, String satPerVbyte, String maxFeePerVbyte, ApiCallback _callback) throws ApiException
      Build call for closeChannel
      Parameters:
      channelPointFundingTxidStr - Hex-encoded string representing the byte-reversed hash of the funding transaction. (required)
      channelPointOutputIndex - The index of the output of the funding transaction (required)
      channelPointFundingTxidBytes - Txid of the funding transaction. When using REST, this field must be encoded as base64. (optional)
      force - If true, then the channel will be closed forcibly. This means the current commitment transaction will be signed and broadcast. (optional)
      targetConf - The target number of blocks that the closure transaction should be confirmed by. (optional)
      satPerByte - Deprecated, use sat_per_vbyte. A manual fee rate set in sat/vbyte that should be used when crafting the closure transaction. (optional)
      deliveryAddress - An optional address to send funds to in the case of a cooperative close. If the channel was opened with an upfront shutdown script and this field is set, the request to close will fail because the channel must pay out to the upfront shutdown addresss. (optional)
      satPerVbyte - A manual fee rate set in sat/vbyte that should be used when crafting the closure transaction. (optional)
      maxFeePerVbyte - The maximum fee rate the closer is willing to pay. NOTE: This field is only respected if we're the initiator of the channel. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • closeChannel

      public StreamResultOfLnrpcCloseStatusUpdate closeChannel(String channelPointFundingTxidStr, Long channelPointOutputIndex, byte[] channelPointFundingTxidBytes, Boolean force, Integer targetConf, String satPerByte, String deliveryAddress, String satPerVbyte, String maxFeePerVbyte) throws ApiException
      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.
      Parameters:
      channelPointFundingTxidStr - Hex-encoded string representing the byte-reversed hash of the funding transaction. (required)
      channelPointOutputIndex - The index of the output of the funding transaction (required)
      channelPointFundingTxidBytes - Txid of the funding transaction. When using REST, this field must be encoded as base64. (optional)
      force - If true, then the channel will be closed forcibly. This means the current commitment transaction will be signed and broadcast. (optional)
      targetConf - The target number of blocks that the closure transaction should be confirmed by. (optional)
      satPerByte - Deprecated, use sat_per_vbyte. A manual fee rate set in sat/vbyte that should be used when crafting the closure transaction. (optional)
      deliveryAddress - An optional address to send funds to in the case of a cooperative close. If the channel was opened with an upfront shutdown script and this field is set, the request to close will fail because the channel must pay out to the upfront shutdown addresss. (optional)
      satPerVbyte - A manual fee rate set in sat/vbyte that should be used when crafting the closure transaction. (optional)
      maxFeePerVbyte - The maximum fee rate the closer is willing to pay. NOTE: This field is only respected if we're the initiator of the channel. (optional)
      Returns:
      StreamResultOfLnrpcCloseStatusUpdate
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • closeChannelWithHttpInfo

      public ApiResponse<StreamResultOfLnrpcCloseStatusUpdate> closeChannelWithHttpInfo(String channelPointFundingTxidStr, Long channelPointOutputIndex, byte[] channelPointFundingTxidBytes, Boolean force, Integer targetConf, String satPerByte, String deliveryAddress, String satPerVbyte, String maxFeePerVbyte) throws ApiException
      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.
      Parameters:
      channelPointFundingTxidStr - Hex-encoded string representing the byte-reversed hash of the funding transaction. (required)
      channelPointOutputIndex - The index of the output of the funding transaction (required)
      channelPointFundingTxidBytes - Txid of the funding transaction. When using REST, this field must be encoded as base64. (optional)
      force - If true, then the channel will be closed forcibly. This means the current commitment transaction will be signed and broadcast. (optional)
      targetConf - The target number of blocks that the closure transaction should be confirmed by. (optional)
      satPerByte - Deprecated, use sat_per_vbyte. A manual fee rate set in sat/vbyte that should be used when crafting the closure transaction. (optional)
      deliveryAddress - An optional address to send funds to in the case of a cooperative close. If the channel was opened with an upfront shutdown script and this field is set, the request to close will fail because the channel must pay out to the upfront shutdown addresss. (optional)
      satPerVbyte - A manual fee rate set in sat/vbyte that should be used when crafting the closure transaction. (optional)
      maxFeePerVbyte - The maximum fee rate the closer is willing to pay. NOTE: This field is only respected if we're the initiator of the channel. (optional)
      Returns:
      ApiResponse<StreamResultOfLnrpcCloseStatusUpdate>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • closeChannelAsync

      public okhttp3.Call closeChannelAsync(String channelPointFundingTxidStr, Long channelPointOutputIndex, byte[] channelPointFundingTxidBytes, Boolean force, Integer targetConf, String satPerByte, String deliveryAddress, String satPerVbyte, String maxFeePerVbyte, ApiCallback<StreamResultOfLnrpcCloseStatusUpdate> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      channelPointFundingTxidStr - Hex-encoded string representing the byte-reversed hash of the funding transaction. (required)
      channelPointOutputIndex - The index of the output of the funding transaction (required)
      channelPointFundingTxidBytes - Txid of the funding transaction. When using REST, this field must be encoded as base64. (optional)
      force - If true, then the channel will be closed forcibly. This means the current commitment transaction will be signed and broadcast. (optional)
      targetConf - The target number of blocks that the closure transaction should be confirmed by. (optional)
      satPerByte - Deprecated, use sat_per_vbyte. A manual fee rate set in sat/vbyte that should be used when crafting the closure transaction. (optional)
      deliveryAddress - An optional address to send funds to in the case of a cooperative close. If the channel was opened with an upfront shutdown script and this field is set, the request to close will fail because the channel must pay out to the upfront shutdown addresss. (optional)
      satPerVbyte - A manual fee rate set in sat/vbyte that should be used when crafting the closure transaction. (optional)
      maxFeePerVbyte - The maximum fee rate the closer is willing to pay. NOTE: This field is only respected if we're the initiator of the channel. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • closedChannelsCall

      public okhttp3.Call closedChannelsCall(Boolean cooperative, Boolean localForce, Boolean remoteForce, Boolean breach, Boolean fundingCanceled, Boolean abandoned, ApiCallback _callback) throws ApiException
      Build call for closedChannels
      Parameters:
      cooperative - (optional)
      localForce - (optional)
      remoteForce - (optional)
      breach - (optional)
      fundingCanceled - (optional)
      abandoned - (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • closedChannels

      public LnrpcClosedChannelsResponse closedChannels(Boolean cooperative, Boolean localForce, Boolean remoteForce, Boolean breach, Boolean fundingCanceled, Boolean abandoned) throws ApiException
      lncli: `closedchannels` ClosedChannels returns a description of all the closed channels that this node was a participant in.
      Parameters:
      cooperative - (optional)
      localForce - (optional)
      remoteForce - (optional)
      breach - (optional)
      fundingCanceled - (optional)
      abandoned - (optional)
      Returns:
      LnrpcClosedChannelsResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • closedChannelsWithHttpInfo

      public ApiResponse<LnrpcClosedChannelsResponse> closedChannelsWithHttpInfo(Boolean cooperative, Boolean localForce, Boolean remoteForce, Boolean breach, Boolean fundingCanceled, Boolean abandoned) throws ApiException
      lncli: `closedchannels` ClosedChannels returns a description of all the closed channels that this node was a participant in.
      Parameters:
      cooperative - (optional)
      localForce - (optional)
      remoteForce - (optional)
      breach - (optional)
      fundingCanceled - (optional)
      abandoned - (optional)
      Returns:
      ApiResponse<LnrpcClosedChannelsResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • closedChannelsAsync

      public okhttp3.Call closedChannelsAsync(Boolean cooperative, Boolean localForce, Boolean remoteForce, Boolean breach, Boolean fundingCanceled, Boolean abandoned, ApiCallback<LnrpcClosedChannelsResponse> _callback) throws ApiException
      lncli: `closedchannels` ClosedChannels returns a description of all the closed channels that this node was a participant in. (asynchronously)
      Parameters:
      cooperative - (optional)
      localForce - (optional)
      remoteForce - (optional)
      breach - (optional)
      fundingCanceled - (optional)
      abandoned - (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • connectPeerCall

      public okhttp3.Call connectPeerCall(LnrpcConnectPeerRequest body, ApiCallback _callback) throws ApiException
      Build call for connectPeer
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • connectPeer

      public Object connectPeer(LnrpcConnectPeerRequest body) throws ApiException
      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.
      Parameters:
      body - (required)
      Returns:
      Object
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • connectPeerWithHttpInfo

      public ApiResponse<Object> connectPeerWithHttpInfo(LnrpcConnectPeerRequest body) throws ApiException
      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.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<Object>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • connectPeerAsync

      public okhttp3.Call connectPeerAsync(LnrpcConnectPeerRequest body, ApiCallback<Object> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • debugLevelCall

      public okhttp3.Call debugLevelCall(LnrpcDebugLevelRequest body, ApiCallback _callback) throws ApiException
      Build call for debugLevel
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • debugLevel

      public LnrpcDebugLevelResponse debugLevel(LnrpcDebugLevelRequest body) throws ApiException
      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.
      Parameters:
      body - (required)
      Returns:
      LnrpcDebugLevelResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • debugLevelWithHttpInfo

      public ApiResponse<LnrpcDebugLevelResponse> debugLevelWithHttpInfo(LnrpcDebugLevelRequest body) throws ApiException
      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.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<LnrpcDebugLevelResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • debugLevelAsync

      public okhttp3.Call debugLevelAsync(LnrpcDebugLevelRequest body, ApiCallback<LnrpcDebugLevelResponse> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • decodePayReqCall

      public okhttp3.Call decodePayReqCall(String payReq, ApiCallback _callback) throws ApiException
      Build call for decodePayReq
      Parameters:
      payReq - The payment request string to be decoded (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • decodePayReq

      public LnrpcPayReq decodePayReq(String payReq) throws ApiException
      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.
      Parameters:
      payReq - The payment request string to be decoded (required)
      Returns:
      LnrpcPayReq
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • decodePayReqWithHttpInfo

      public ApiResponse<LnrpcPayReq> decodePayReqWithHttpInfo(String payReq) throws ApiException
      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.
      Parameters:
      payReq - The payment request string to be decoded (required)
      Returns:
      ApiResponse<LnrpcPayReq>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • decodePayReqAsync

      public okhttp3.Call decodePayReqAsync(String payReq, ApiCallback<LnrpcPayReq> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      payReq - The payment request string to be decoded (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • deleteAllPaymentsCall

      public okhttp3.Call deleteAllPaymentsCall(Boolean failedPaymentsOnly, Boolean failedHtlcsOnly, ApiCallback _callback) throws ApiException
      Build call for deleteAllPayments
      Parameters:
      failedPaymentsOnly - Only delete failed payments. (optional)
      failedHtlcsOnly - Only delete failed HTLCs from payments, not the payment itself. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • deleteAllPayments

      public Object deleteAllPayments(Boolean failedPaymentsOnly, Boolean failedHtlcsOnly) throws ApiException
      DeleteAllPayments deletes all outgoing payments from DB. Note that it will not attempt to delete In-Flight payments, since that would be unsafe.
      Parameters:
      failedPaymentsOnly - Only delete failed payments. (optional)
      failedHtlcsOnly - Only delete failed HTLCs from payments, not the payment itself. (optional)
      Returns:
      Object
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • deleteAllPaymentsWithHttpInfo

      public ApiResponse<Object> deleteAllPaymentsWithHttpInfo(Boolean failedPaymentsOnly, Boolean failedHtlcsOnly) throws ApiException
      DeleteAllPayments deletes all outgoing payments from DB. Note that it will not attempt to delete In-Flight payments, since that would be unsafe.
      Parameters:
      failedPaymentsOnly - Only delete failed payments. (optional)
      failedHtlcsOnly - Only delete failed HTLCs from payments, not the payment itself. (optional)
      Returns:
      ApiResponse<Object>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • deleteAllPaymentsAsync

      public okhttp3.Call deleteAllPaymentsAsync(Boolean failedPaymentsOnly, Boolean failedHtlcsOnly, ApiCallback<Object> _callback) throws ApiException
      DeleteAllPayments deletes all outgoing payments from DB. Note that it will not attempt to delete In-Flight payments, since that would be unsafe. (asynchronously)
      Parameters:
      failedPaymentsOnly - Only delete failed payments. (optional)
      failedHtlcsOnly - Only delete failed HTLCs from payments, not the payment itself. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • deleteMacaroonIDCall

      public okhttp3.Call deleteMacaroonIDCall(String rootKeyId, ApiCallback _callback) throws ApiException
      Build call for deleteMacaroonID
      Parameters:
      rootKeyId - The root key ID to be removed. (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • deleteMacaroonID

      public LnrpcDeleteMacaroonIDResponse deleteMacaroonID(String rootKeyId) throws ApiException
      lncli: `deletemacaroonid` DeleteMacaroonID deletes the specified macaroon ID and invalidates all macaroons derived from that ID.
      Parameters:
      rootKeyId - The root key ID to be removed. (required)
      Returns:
      LnrpcDeleteMacaroonIDResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • deleteMacaroonIDWithHttpInfo

      public ApiResponse<LnrpcDeleteMacaroonIDResponse> deleteMacaroonIDWithHttpInfo(String rootKeyId) throws ApiException
      lncli: `deletemacaroonid` DeleteMacaroonID deletes the specified macaroon ID and invalidates all macaroons derived from that ID.
      Parameters:
      rootKeyId - The root key ID to be removed. (required)
      Returns:
      ApiResponse<LnrpcDeleteMacaroonIDResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • deleteMacaroonIDAsync

      public okhttp3.Call deleteMacaroonIDAsync(String rootKeyId, ApiCallback<LnrpcDeleteMacaroonIDResponse> _callback) throws ApiException
      lncli: `deletemacaroonid` DeleteMacaroonID deletes the specified macaroon ID and invalidates all macaroons derived from that ID. (asynchronously)
      Parameters:
      rootKeyId - The root key ID to be removed. (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • deletePaymentCall

      public okhttp3.Call deletePaymentCall(byte[] paymentHash, Boolean failedHtlcsOnly, ApiCallback _callback) throws ApiException
      Build call for deletePayment
      Parameters:
      paymentHash - Payment hash to delete. (optional)
      failedHtlcsOnly - Only delete failed HTLCs from the payment, not the payment itself. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • deletePayment

      public Object deletePayment(byte[] paymentHash, Boolean failedHtlcsOnly) throws ApiException
      DeletePayment deletes an outgoing payment from DB. Note that it will not attempt to delete an In-Flight payment, since that would be unsafe.
      Parameters:
      paymentHash - Payment hash to delete. (optional)
      failedHtlcsOnly - Only delete failed HTLCs from the payment, not the payment itself. (optional)
      Returns:
      Object
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • deletePaymentWithHttpInfo

      public ApiResponse<Object> deletePaymentWithHttpInfo(byte[] paymentHash, Boolean failedHtlcsOnly) throws ApiException
      DeletePayment deletes an outgoing payment from DB. Note that it will not attempt to delete an In-Flight payment, since that would be unsafe.
      Parameters:
      paymentHash - Payment hash to delete. (optional)
      failedHtlcsOnly - Only delete failed HTLCs from the payment, not the payment itself. (optional)
      Returns:
      ApiResponse<Object>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • deletePaymentAsync

      public okhttp3.Call deletePaymentAsync(byte[] paymentHash, Boolean failedHtlcsOnly, ApiCallback<Object> _callback) throws ApiException
      DeletePayment deletes an outgoing payment from DB. Note that it will not attempt to delete an In-Flight payment, since that would be unsafe. (asynchronously)
      Parameters:
      paymentHash - Payment hash to delete. (optional)
      failedHtlcsOnly - Only delete failed HTLCs from the payment, not the payment itself. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • describeGraphCall

      public okhttp3.Call describeGraphCall(Boolean includeUnannounced, ApiCallback _callback) throws ApiException
      Build call for describeGraph
      Parameters:
      includeUnannounced - Whether unannounced channels are included in the response or not. If set, unannounced channels are included. Unannounced channels are both private channels, and public channels that are not yet announced to the network. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • describeGraph

      public LnrpcChannelGraph describeGraph(Boolean includeUnannounced) throws ApiException
      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.
      Parameters:
      includeUnannounced - Whether unannounced channels are included in the response or not. If set, unannounced channels are included. Unannounced channels are both private channels, and public channels that are not yet announced to the network. (optional)
      Returns:
      LnrpcChannelGraph
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • describeGraphWithHttpInfo

      public ApiResponse<LnrpcChannelGraph> describeGraphWithHttpInfo(Boolean includeUnannounced) throws ApiException
      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.
      Parameters:
      includeUnannounced - Whether unannounced channels are included in the response or not. If set, unannounced channels are included. Unannounced channels are both private channels, and public channels that are not yet announced to the network. (optional)
      Returns:
      ApiResponse<LnrpcChannelGraph>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • describeGraphAsync

      public okhttp3.Call describeGraphAsync(Boolean includeUnannounced, ApiCallback<LnrpcChannelGraph> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      includeUnannounced - Whether unannounced channels are included in the response or not. If set, unannounced channels are included. Unannounced channels are both private channels, and public channels that are not yet announced to the network. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • disconnectPeerCall

      public okhttp3.Call disconnectPeerCall(String pubKey, ApiCallback _callback) throws ApiException
      Build call for disconnectPeer
      Parameters:
      pubKey - The pubkey of the node to disconnect from (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • disconnectPeer

      public Object disconnectPeer(String pubKey) throws ApiException
      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.
      Parameters:
      pubKey - The pubkey of the node to disconnect from (required)
      Returns:
      Object
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • disconnectPeerWithHttpInfo

      public ApiResponse<Object> disconnectPeerWithHttpInfo(String pubKey) throws ApiException
      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.
      Parameters:
      pubKey - The pubkey of the node to disconnect from (required)
      Returns:
      ApiResponse<Object>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • disconnectPeerAsync

      public okhttp3.Call disconnectPeerAsync(String pubKey, ApiCallback<Object> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      pubKey - The pubkey of the node to disconnect from (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • estimateFeeCall

      public okhttp3.Call estimateFeeCall(Integer targetConf, Integer minConfs, Boolean spendUnconfirmed, ApiCallback _callback) throws ApiException
      Build call for estimateFee
      Parameters:
      targetConf - The target number of blocks that this transaction should be confirmed by. (optional)
      minConfs - The minimum number of confirmations each one of your outputs used for the transaction must satisfy. (optional)
      spendUnconfirmed - Whether unconfirmed outputs should be used as inputs for the transaction. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • estimateFee

      public LnrpcEstimateFeeResponse estimateFee(Integer targetConf, Integer minConfs, Boolean spendUnconfirmed) throws ApiException
      lncli: `estimatefee` EstimateFee asks the chain backend to estimate the fee rate and total fees for a transaction that pays to multiple specified outputs. When using REST, the `AddrToAmount` map type can be set by appending `&AddrToAmount[<address>]=<amount_to_send>` to the URL. Unfortunately this map type doesn't appear in the REST API documentation because of a bug in the grpc-gateway library.
      Parameters:
      targetConf - The target number of blocks that this transaction should be confirmed by. (optional)
      minConfs - The minimum number of confirmations each one of your outputs used for the transaction must satisfy. (optional)
      spendUnconfirmed - Whether unconfirmed outputs should be used as inputs for the transaction. (optional)
      Returns:
      LnrpcEstimateFeeResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • estimateFeeWithHttpInfo

      public ApiResponse<LnrpcEstimateFeeResponse> estimateFeeWithHttpInfo(Integer targetConf, Integer minConfs, Boolean spendUnconfirmed) throws ApiException
      lncli: `estimatefee` EstimateFee asks the chain backend to estimate the fee rate and total fees for a transaction that pays to multiple specified outputs. When using REST, the `AddrToAmount` map type can be set by appending `&AddrToAmount[<address>]=<amount_to_send>` to the URL. Unfortunately this map type doesn't appear in the REST API documentation because of a bug in the grpc-gateway library.
      Parameters:
      targetConf - The target number of blocks that this transaction should be confirmed by. (optional)
      minConfs - The minimum number of confirmations each one of your outputs used for the transaction must satisfy. (optional)
      spendUnconfirmed - Whether unconfirmed outputs should be used as inputs for the transaction. (optional)
      Returns:
      ApiResponse<LnrpcEstimateFeeResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • estimateFeeAsync

      public okhttp3.Call estimateFeeAsync(Integer targetConf, Integer minConfs, Boolean spendUnconfirmed, ApiCallback<LnrpcEstimateFeeResponse> _callback) throws ApiException
      lncli: `estimatefee` EstimateFee asks the chain backend to estimate the fee rate and total fees for a transaction that pays to multiple specified outputs. (asynchronously) When using REST, the `AddrToAmount` map type can be set by appending `&AddrToAmount[<address>]=<amount_to_send>` to the URL. Unfortunately this map type doesn't appear in the REST API documentation because of a bug in the grpc-gateway library.
      Parameters:
      targetConf - The target number of blocks that this transaction should be confirmed by. (optional)
      minConfs - The minimum number of confirmations each one of your outputs used for the transaction must satisfy. (optional)
      spendUnconfirmed - Whether unconfirmed outputs should be used as inputs for the transaction. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • exportAllChannelBackupsCall

      public okhttp3.Call exportAllChannelBackupsCall(ApiCallback _callback) throws ApiException
      Build call for exportAllChannelBackups
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • exportAllChannelBackups

      public LnrpcChanBackupSnapshot exportAllChannelBackups() throws ApiException
      ExportAllChannelBackups returns static channel backups for all existing channels known to lnd. A set of regular singular static channel backups for each channel are returned. Additionally, a multi-channel backup is returned as well, which contains a single encrypted blob containing the backups of each channel.
      Returns:
      LnrpcChanBackupSnapshot
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • exportAllChannelBackupsWithHttpInfo

      public ApiResponse<LnrpcChanBackupSnapshot> exportAllChannelBackupsWithHttpInfo() throws ApiException
      ExportAllChannelBackups returns static channel backups for all existing channels known to lnd. A set of regular singular static channel backups for each channel are returned. Additionally, a multi-channel backup is returned as well, which contains a single encrypted blob containing the backups of each channel.
      Returns:
      ApiResponse<LnrpcChanBackupSnapshot>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • exportAllChannelBackupsAsync

      public okhttp3.Call exportAllChannelBackupsAsync(ApiCallback<LnrpcChanBackupSnapshot> _callback) throws ApiException
      ExportAllChannelBackups returns static channel backups for all existing channels known to lnd. A set of regular singular static channel backups for each channel are returned. Additionally, a multi-channel backup is returned as well, which contains a single encrypted blob containing the backups of each channel. (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • exportChannelBackupCall

      public okhttp3.Call exportChannelBackupCall(String chanPointFundingTxidStr, Long chanPointOutputIndex, byte[] chanPointFundingTxidBytes, ApiCallback _callback) throws ApiException
      Build call for exportChannelBackup
      Parameters:
      chanPointFundingTxidStr - Hex-encoded string representing the byte-reversed hash of the funding transaction. (required)
      chanPointOutputIndex - The index of the output of the funding transaction (required)
      chanPointFundingTxidBytes - Txid of the funding transaction. When using REST, this field must be encoded as base64. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • exportChannelBackup

      public LnrpcChannelBackup exportChannelBackup(String chanPointFundingTxidStr, Long chanPointOutputIndex, byte[] chanPointFundingTxidBytes) throws ApiException
      lncli: `exportchanbackup` ExportChannelBackup attempts to return an encrypted static channel backup for the target channel identified by it channel point. The backup is encrypted with a key generated from the aezeed seed of the user. The returned backup can either be restored using the RestoreChannelBackup method once lnd is running, or via the InitWallet and UnlockWallet methods from the WalletUnlocker service.
      Parameters:
      chanPointFundingTxidStr - Hex-encoded string representing the byte-reversed hash of the funding transaction. (required)
      chanPointOutputIndex - The index of the output of the funding transaction (required)
      chanPointFundingTxidBytes - Txid of the funding transaction. When using REST, this field must be encoded as base64. (optional)
      Returns:
      LnrpcChannelBackup
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • exportChannelBackupWithHttpInfo

      public ApiResponse<LnrpcChannelBackup> exportChannelBackupWithHttpInfo(String chanPointFundingTxidStr, Long chanPointOutputIndex, byte[] chanPointFundingTxidBytes) throws ApiException
      lncli: `exportchanbackup` ExportChannelBackup attempts to return an encrypted static channel backup for the target channel identified by it channel point. The backup is encrypted with a key generated from the aezeed seed of the user. The returned backup can either be restored using the RestoreChannelBackup method once lnd is running, or via the InitWallet and UnlockWallet methods from the WalletUnlocker service.
      Parameters:
      chanPointFundingTxidStr - Hex-encoded string representing the byte-reversed hash of the funding transaction. (required)
      chanPointOutputIndex - The index of the output of the funding transaction (required)
      chanPointFundingTxidBytes - Txid of the funding transaction. When using REST, this field must be encoded as base64. (optional)
      Returns:
      ApiResponse<LnrpcChannelBackup>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • exportChannelBackupAsync

      public okhttp3.Call exportChannelBackupAsync(String chanPointFundingTxidStr, Long chanPointOutputIndex, byte[] chanPointFundingTxidBytes, ApiCallback<LnrpcChannelBackup> _callback) throws ApiException
      lncli: `exportchanbackup` ExportChannelBackup attempts to return an encrypted static channel backup for the target channel identified by it channel point. The backup is encrypted with a key generated from the aezeed seed of the user. The returned backup can either be restored using the RestoreChannelBackup method once lnd is running, or via the InitWallet and UnlockWallet methods from the WalletUnlocker service. (asynchronously)
      Parameters:
      chanPointFundingTxidStr - Hex-encoded string representing the byte-reversed hash of the funding transaction. (required)
      chanPointOutputIndex - The index of the output of the funding transaction (required)
      chanPointFundingTxidBytes - Txid of the funding transaction. When using REST, this field must be encoded as base64. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • feeReportCall

      public okhttp3.Call feeReportCall(ApiCallback _callback) throws ApiException
      Build call for feeReport
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • feeReport

      public LnrpcFeeReportResponse feeReport() throws ApiException
      lncli: `feereport` FeeReport allows the caller to obtain a report detailing the current fee schedule enforced by the node globally for each channel.
      Returns:
      LnrpcFeeReportResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • feeReportWithHttpInfo

      public ApiResponse<LnrpcFeeReportResponse> feeReportWithHttpInfo() throws ApiException
      lncli: `feereport` FeeReport allows the caller to obtain a report detailing the current fee schedule enforced by the node globally for each channel.
      Returns:
      ApiResponse<LnrpcFeeReportResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • feeReportAsync

      public okhttp3.Call feeReportAsync(ApiCallback<LnrpcFeeReportResponse> _callback) throws ApiException
      lncli: `feereport` FeeReport allows the caller to obtain a report detailing the current fee schedule enforced by the node globally for each channel. (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • forwardingHistoryCall

      public okhttp3.Call forwardingHistoryCall(LnrpcForwardingHistoryRequest body, ApiCallback _callback) throws ApiException
      Build call for forwardingHistory
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • forwardingHistory

      public LnrpcForwardingHistoryResponse forwardingHistory(LnrpcForwardingHistoryRequest body) throws ApiException
      lncli: `fwdinghistory` ForwardingHistory allows the caller to query the htlcswitch for a record of all HTLCs forwarded within the target time range, and integer offset within that time range, for a maximum number of events. If no maximum number of events is specified, up to 100 events will be returned. If no time-range is specified, then events will be returned in the order that they occured. 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.
      Parameters:
      body - (required)
      Returns:
      LnrpcForwardingHistoryResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • forwardingHistoryWithHttpInfo

      public ApiResponse<LnrpcForwardingHistoryResponse> forwardingHistoryWithHttpInfo(LnrpcForwardingHistoryRequest body) throws ApiException
      lncli: `fwdinghistory` ForwardingHistory allows the caller to query the htlcswitch for a record of all HTLCs forwarded within the target time range, and integer offset within that time range, for a maximum number of events. If no maximum number of events is specified, up to 100 events will be returned. If no time-range is specified, then events will be returned in the order that they occured. 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.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<LnrpcForwardingHistoryResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • forwardingHistoryAsync

      public okhttp3.Call forwardingHistoryAsync(LnrpcForwardingHistoryRequest body, ApiCallback<LnrpcForwardingHistoryResponse> _callback) throws ApiException
      lncli: `fwdinghistory` ForwardingHistory allows the caller to query the htlcswitch for a record of all HTLCs forwarded within the target time range, and integer offset within that time range, for a maximum number of events. If no maximum number of events is specified, up to 100 events will be returned. If no time-range is specified, then events will be returned in the order that they occured. (asynchronously) 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.
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • fundingStateStepCall

      public okhttp3.Call fundingStateStepCall(LnrpcFundingTransitionMsg body, ApiCallback _callback) throws ApiException
      Build call for fundingStateStep
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • fundingStateStep

      public Object fundingStateStep(LnrpcFundingTransitionMsg body) throws ApiException
      FundingStateStep is an advanced funding related call that allows the caller to either execute some preparatory steps for a funding workflow, or manually progress a funding workflow. The primary way a funding flow is identified is via its pending channel ID. As an example, this method can be used to specify that we're expecting a funding flow for a particular pending channel ID, for which we need to use specific parameters. Alternatively, this can be used to interactively drive PSBT signing for funding for partially complete funding transactions.
      Parameters:
      body - (required)
      Returns:
      Object
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • fundingStateStepWithHttpInfo

      public ApiResponse<Object> fundingStateStepWithHttpInfo(LnrpcFundingTransitionMsg body) throws ApiException
      FundingStateStep is an advanced funding related call that allows the caller to either execute some preparatory steps for a funding workflow, or manually progress a funding workflow. The primary way a funding flow is identified is via its pending channel ID. As an example, this method can be used to specify that we're expecting a funding flow for a particular pending channel ID, for which we need to use specific parameters. Alternatively, this can be used to interactively drive PSBT signing for funding for partially complete funding transactions.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<Object>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • fundingStateStepAsync

      public okhttp3.Call fundingStateStepAsync(LnrpcFundingTransitionMsg body, ApiCallback<Object> _callback) throws ApiException
      FundingStateStep is an advanced funding related call that allows the caller to either execute some preparatory steps for a funding workflow, or manually progress a funding workflow. The primary way a funding flow is identified is via its pending channel ID. As an example, this method can be used to specify that we're expecting a funding flow for a particular pending channel ID, for which we need to use specific parameters. Alternatively, this can be used to interactively drive PSBT signing for funding for partially complete funding transactions. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • getChanInfoCall

      public okhttp3.Call getChanInfoCall(String chanId, ApiCallback _callback) throws ApiException
      Build call for getChanInfo
      Parameters:
      chanId - 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. (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • getChanInfo

      public LnrpcChannelEdge getChanInfo(String chanId) throws ApiException
      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.
      Parameters:
      chanId - 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. (required)
      Returns:
      LnrpcChannelEdge
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • getChanInfoWithHttpInfo

      public ApiResponse<LnrpcChannelEdge> getChanInfoWithHttpInfo(String chanId) throws ApiException
      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.
      Parameters:
      chanId - 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. (required)
      Returns:
      ApiResponse<LnrpcChannelEdge>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • getChanInfoAsync

      public okhttp3.Call getChanInfoAsync(String chanId, ApiCallback<LnrpcChannelEdge> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      chanId - 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. (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • getInfoCall

      public okhttp3.Call getInfoCall(ApiCallback _callback) throws ApiException
      Build call for getInfo
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • getInfo

      public LnrpcGetInfoResponse getInfo() throws ApiException
      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.
      Returns:
      LnrpcGetInfoResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • getInfoWithHttpInfo

      public ApiResponse<LnrpcGetInfoResponse> getInfoWithHttpInfo() throws ApiException
      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.
      Returns:
      ApiResponse<LnrpcGetInfoResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • getInfoAsync

      public okhttp3.Call getInfoAsync(ApiCallback<LnrpcGetInfoResponse> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • getNetworkInfoCall

      public okhttp3.Call getNetworkInfoCall(ApiCallback _callback) throws ApiException
      Build call for getNetworkInfo
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • getNetworkInfo

      public LnrpcNetworkInfo getNetworkInfo() throws ApiException
      lncli: `getnetworkinfo` GetNetworkInfo returns some basic stats about the known channel graph from the point of view of the node.
      Returns:
      LnrpcNetworkInfo
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • getNetworkInfoWithHttpInfo

      public ApiResponse<LnrpcNetworkInfo> getNetworkInfoWithHttpInfo() throws ApiException
      lncli: `getnetworkinfo` GetNetworkInfo returns some basic stats about the known channel graph from the point of view of the node.
      Returns:
      ApiResponse<LnrpcNetworkInfo>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • getNetworkInfoAsync

      public okhttp3.Call getNetworkInfoAsync(ApiCallback<LnrpcNetworkInfo> _callback) throws ApiException
      lncli: `getnetworkinfo` GetNetworkInfo returns some basic stats about the known channel graph from the point of view of the node. (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • getNodeInfoCall

      public okhttp3.Call getNodeInfoCall(String pubKey, Boolean includeChannels, ApiCallback _callback) throws ApiException
      Build call for getNodeInfo
      Parameters:
      pubKey - The 33-byte hex-encoded compressed public of the target node (required)
      includeChannels - If true, will include all known channels associated with the node. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • getNodeInfo

      public LnrpcNodeInfo getNodeInfo(String pubKey, Boolean includeChannels) throws ApiException
      lncli: `getnodeinfo` GetNodeInfo returns the latest advertised, aggregated, and authenticated channel information for the specified node identified by its public key.
      Parameters:
      pubKey - The 33-byte hex-encoded compressed public of the target node (required)
      includeChannels - If true, will include all known channels associated with the node. (optional)
      Returns:
      LnrpcNodeInfo
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • getNodeInfoWithHttpInfo

      public ApiResponse<LnrpcNodeInfo> getNodeInfoWithHttpInfo(String pubKey, Boolean includeChannels) throws ApiException
      lncli: `getnodeinfo` GetNodeInfo returns the latest advertised, aggregated, and authenticated channel information for the specified node identified by its public key.
      Parameters:
      pubKey - The 33-byte hex-encoded compressed public of the target node (required)
      includeChannels - If true, will include all known channels associated with the node. (optional)
      Returns:
      ApiResponse<LnrpcNodeInfo>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • getNodeInfoAsync

      public okhttp3.Call getNodeInfoAsync(String pubKey, Boolean includeChannels, ApiCallback<LnrpcNodeInfo> _callback) throws ApiException
      lncli: `getnodeinfo` GetNodeInfo returns the latest advertised, aggregated, and authenticated channel information for the specified node identified by its public key. (asynchronously)
      Parameters:
      pubKey - The 33-byte hex-encoded compressed public of the target node (required)
      includeChannels - If true, will include all known channels associated with the node. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • getNodeMetricsCall

      public okhttp3.Call getNodeMetricsCall(List<String> types, ApiCallback _callback) throws ApiException
      Build call for getNodeMetrics
      Parameters:
      types - The requested node metrics. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • getNodeMetrics

      public LnrpcNodeMetricsResponse getNodeMetrics(List<String> types) throws ApiException
      lncli: `getnodemetrics` GetNodeMetrics returns node metrics calculated from the graph. Currently the only supported metric is betweenness centrality of individual nodes.
      Parameters:
      types - The requested node metrics. (optional)
      Returns:
      LnrpcNodeMetricsResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • getNodeMetricsWithHttpInfo

      public ApiResponse<LnrpcNodeMetricsResponse> getNodeMetricsWithHttpInfo(List<String> types) throws ApiException
      lncli: `getnodemetrics` GetNodeMetrics returns node metrics calculated from the graph. Currently the only supported metric is betweenness centrality of individual nodes.
      Parameters:
      types - The requested node metrics. (optional)
      Returns:
      ApiResponse<LnrpcNodeMetricsResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • getNodeMetricsAsync

      public okhttp3.Call getNodeMetricsAsync(List<String> types, ApiCallback<LnrpcNodeMetricsResponse> _callback) throws ApiException
      lncli: `getnodemetrics` GetNodeMetrics returns node metrics calculated from the graph. Currently the only supported metric is betweenness centrality of individual nodes. (asynchronously)
      Parameters:
      types - The requested node metrics. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • getRecoveryInfoCall

      public okhttp3.Call getRecoveryInfoCall(ApiCallback _callback) throws ApiException
      Build call for getRecoveryInfo
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • getRecoveryInfo

      public LnrpcGetRecoveryInfoResponse getRecoveryInfo() throws ApiException
      * lncli: `getrecoveryinfo` GetRecoveryInfo returns information concerning the recovery mode including whether it's in a recovery mode, whether the recovery is finished, and the progress made so far.
      Returns:
      LnrpcGetRecoveryInfoResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • getRecoveryInfoWithHttpInfo

      public ApiResponse<LnrpcGetRecoveryInfoResponse> getRecoveryInfoWithHttpInfo() throws ApiException
      * lncli: `getrecoveryinfo` GetRecoveryInfo returns information concerning the recovery mode including whether it's in a recovery mode, whether the recovery is finished, and the progress made so far.
      Returns:
      ApiResponse<LnrpcGetRecoveryInfoResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • getRecoveryInfoAsync

      public okhttp3.Call getRecoveryInfoAsync(ApiCallback<LnrpcGetRecoveryInfoResponse> _callback) throws ApiException
      * lncli: `getrecoveryinfo` GetRecoveryInfo returns information concerning the recovery mode including whether it's in a recovery mode, whether the recovery is finished, and the progress made so far. (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • getTransactionsCall

      public okhttp3.Call getTransactionsCall(Integer startHeight, Integer endHeight, String account, ApiCallback _callback) throws ApiException
      Build call for getTransactions
      Parameters:
      startHeight - The height from which to list transactions, inclusive. If this value is greater than end_height, transactions will be read in reverse. (optional)
      endHeight - The height until which to list transactions, inclusive. To include unconfirmed transactions, this value should be set to -1, which will return transactions from start_height until the current chain tip and unconfirmed transactions. If no end_height is provided, the call will default to this option. (optional)
      account - An optional filter to only include transactions relevant to an account. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • getTransactions

      public LnrpcTransactionDetails getTransactions(Integer startHeight, Integer endHeight, String account) throws ApiException
      lncli: `listchaintxns` GetTransactions returns a list describing all the known transactions relevant to the wallet.
      Parameters:
      startHeight - The height from which to list transactions, inclusive. If this value is greater than end_height, transactions will be read in reverse. (optional)
      endHeight - The height until which to list transactions, inclusive. To include unconfirmed transactions, this value should be set to -1, which will return transactions from start_height until the current chain tip and unconfirmed transactions. If no end_height is provided, the call will default to this option. (optional)
      account - An optional filter to only include transactions relevant to an account. (optional)
      Returns:
      LnrpcTransactionDetails
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • getTransactionsWithHttpInfo

      public ApiResponse<LnrpcTransactionDetails> getTransactionsWithHttpInfo(Integer startHeight, Integer endHeight, String account) throws ApiException
      lncli: `listchaintxns` GetTransactions returns a list describing all the known transactions relevant to the wallet.
      Parameters:
      startHeight - The height from which to list transactions, inclusive. If this value is greater than end_height, transactions will be read in reverse. (optional)
      endHeight - The height until which to list transactions, inclusive. To include unconfirmed transactions, this value should be set to -1, which will return transactions from start_height until the current chain tip and unconfirmed transactions. If no end_height is provided, the call will default to this option. (optional)
      account - An optional filter to only include transactions relevant to an account. (optional)
      Returns:
      ApiResponse<LnrpcTransactionDetails>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • getTransactionsAsync

      public okhttp3.Call getTransactionsAsync(Integer startHeight, Integer endHeight, String account, ApiCallback<LnrpcTransactionDetails> _callback) throws ApiException
      lncli: `listchaintxns` GetTransactions returns a list describing all the known transactions relevant to the wallet. (asynchronously)
      Parameters:
      startHeight - The height from which to list transactions, inclusive. If this value is greater than end_height, transactions will be read in reverse. (optional)
      endHeight - The height until which to list transactions, inclusive. To include unconfirmed transactions, this value should be set to -1, which will return transactions from start_height until the current chain tip and unconfirmed transactions. If no end_height is provided, the call will default to this option. (optional)
      account - An optional filter to only include transactions relevant to an account. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • listAliasesCall

      public okhttp3.Call listAliasesCall(ApiCallback _callback) throws ApiException
      Build call for listAliases
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • listAliases

      public LnrpcListAliasesResponse listAliases() throws ApiException
      lncli: `listaliases` ListAliases returns the set of all aliases that have ever existed with their confirmed SCID (if it exists) and/or the base SCID (in the case of zero conf).
      Returns:
      LnrpcListAliasesResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listAliasesWithHttpInfo

      public ApiResponse<LnrpcListAliasesResponse> listAliasesWithHttpInfo() throws ApiException
      lncli: `listaliases` ListAliases returns the set of all aliases that have ever existed with their confirmed SCID (if it exists) and/or the base SCID (in the case of zero conf).
      Returns:
      ApiResponse<LnrpcListAliasesResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listAliasesAsync

      public okhttp3.Call listAliasesAsync(ApiCallback<LnrpcListAliasesResponse> _callback) throws ApiException
      lncli: `listaliases` ListAliases returns the set of all aliases that have ever existed with their confirmed SCID (if it exists) and/or the base SCID (in the case of zero conf). (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • listChannelsCall

      public okhttp3.Call listChannelsCall(Boolean activeOnly, Boolean inactiveOnly, Boolean publicOnly, Boolean privateOnly, byte[] peer, Boolean peerAliasLookup, ApiCallback _callback) throws ApiException
      Build call for listChannels
      Parameters:
      activeOnly - (optional)
      inactiveOnly - (optional)
      publicOnly - (optional)
      privateOnly - (optional)
      peer - Filters the response for channels with a target peer's pubkey. If peer is empty, all channels will be returned. (optional)
      peerAliasLookup - Informs the server if the peer alias lookup per channel should be enabled. It is turned off by default in order to avoid degradation of performance for existing clients. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • listChannels

      public LnrpcListChannelsResponse listChannels(Boolean activeOnly, Boolean inactiveOnly, Boolean publicOnly, Boolean privateOnly, byte[] peer, Boolean peerAliasLookup) throws ApiException
      lncli: `listchannels` ListChannels returns a description of all the open channels that this node is a participant in.
      Parameters:
      activeOnly - (optional)
      inactiveOnly - (optional)
      publicOnly - (optional)
      privateOnly - (optional)
      peer - Filters the response for channels with a target peer's pubkey. If peer is empty, all channels will be returned. (optional)
      peerAliasLookup - Informs the server if the peer alias lookup per channel should be enabled. It is turned off by default in order to avoid degradation of performance for existing clients. (optional)
      Returns:
      LnrpcListChannelsResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listChannelsWithHttpInfo

      public ApiResponse<LnrpcListChannelsResponse> listChannelsWithHttpInfo(Boolean activeOnly, Boolean inactiveOnly, Boolean publicOnly, Boolean privateOnly, byte[] peer, Boolean peerAliasLookup) throws ApiException
      lncli: `listchannels` ListChannels returns a description of all the open channels that this node is a participant in.
      Parameters:
      activeOnly - (optional)
      inactiveOnly - (optional)
      publicOnly - (optional)
      privateOnly - (optional)
      peer - Filters the response for channels with a target peer's pubkey. If peer is empty, all channels will be returned. (optional)
      peerAliasLookup - Informs the server if the peer alias lookup per channel should be enabled. It is turned off by default in order to avoid degradation of performance for existing clients. (optional)
      Returns:
      ApiResponse<LnrpcListChannelsResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listChannelsAsync

      public okhttp3.Call listChannelsAsync(Boolean activeOnly, Boolean inactiveOnly, Boolean publicOnly, Boolean privateOnly, byte[] peer, Boolean peerAliasLookup, ApiCallback<LnrpcListChannelsResponse> _callback) throws ApiException
      lncli: `listchannels` ListChannels returns a description of all the open channels that this node is a participant in. (asynchronously)
      Parameters:
      activeOnly - (optional)
      inactiveOnly - (optional)
      publicOnly - (optional)
      privateOnly - (optional)
      peer - Filters the response for channels with a target peer's pubkey. If peer is empty, all channels will be returned. (optional)
      peerAliasLookup - Informs the server if the peer alias lookup per channel should be enabled. It is turned off by default in order to avoid degradation of performance for existing clients. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • listInvoicesCall

      public okhttp3.Call listInvoicesCall(Boolean pendingOnly, String indexOffset, String numMaxInvoices, Boolean reversed, String creationDateStart, String creationDateEnd, ApiCallback _callback) throws ApiException
      Build call for listInvoices
      Parameters:
      pendingOnly - If set, only invoices that are not settled and not canceled will be returned in the response. (optional)
      indexOffset - 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. (optional)
      numMaxInvoices - The max number of invoices to return in the response to this query. (optional)
      reversed - If set, the invoices returned will result from seeking backwards from the specified index offset. This can be used to paginate backwards. (optional)
      creationDateStart - If set, returns all invoices with a creation date greater than or equal to it. Measured in seconds since the unix epoch. (optional)
      creationDateEnd - If set, returns all invoices with a creation date less than or equal to it. Measured in seconds since the unix epoch. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • listInvoices

      public LnrpcListInvoiceResponse listInvoices(Boolean pendingOnly, String indexOffset, String numMaxInvoices, Boolean reversed, String creationDateStart, String creationDateEnd) throws ApiException
      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. By default, the first 100 invoices created will be returned. Backwards pagination is also supported through the Reversed flag.
      Parameters:
      pendingOnly - If set, only invoices that are not settled and not canceled will be returned in the response. (optional)
      indexOffset - 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. (optional)
      numMaxInvoices - The max number of invoices to return in the response to this query. (optional)
      reversed - If set, the invoices returned will result from seeking backwards from the specified index offset. This can be used to paginate backwards. (optional)
      creationDateStart - If set, returns all invoices with a creation date greater than or equal to it. Measured in seconds since the unix epoch. (optional)
      creationDateEnd - If set, returns all invoices with a creation date less than or equal to it. Measured in seconds since the unix epoch. (optional)
      Returns:
      LnrpcListInvoiceResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listInvoicesWithHttpInfo

      public ApiResponse<LnrpcListInvoiceResponse> listInvoicesWithHttpInfo(Boolean pendingOnly, String indexOffset, String numMaxInvoices, Boolean reversed, String creationDateStart, String creationDateEnd) throws ApiException
      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. By default, the first 100 invoices created will be returned. Backwards pagination is also supported through the Reversed flag.
      Parameters:
      pendingOnly - If set, only invoices that are not settled and not canceled will be returned in the response. (optional)
      indexOffset - 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. (optional)
      numMaxInvoices - The max number of invoices to return in the response to this query. (optional)
      reversed - If set, the invoices returned will result from seeking backwards from the specified index offset. This can be used to paginate backwards. (optional)
      creationDateStart - If set, returns all invoices with a creation date greater than or equal to it. Measured in seconds since the unix epoch. (optional)
      creationDateEnd - If set, returns all invoices with a creation date less than or equal to it. Measured in seconds since the unix epoch. (optional)
      Returns:
      ApiResponse<LnrpcListInvoiceResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listInvoicesAsync

      public okhttp3.Call listInvoicesAsync(Boolean pendingOnly, String indexOffset, String numMaxInvoices, Boolean reversed, String creationDateStart, String creationDateEnd, ApiCallback<LnrpcListInvoiceResponse> _callback) throws ApiException
      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. By default, the first 100 invoices created will be returned. Backwards pagination is also supported through the Reversed flag. (asynchronously)
      Parameters:
      pendingOnly - If set, only invoices that are not settled and not canceled will be returned in the response. (optional)
      indexOffset - 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. (optional)
      numMaxInvoices - The max number of invoices to return in the response to this query. (optional)
      reversed - If set, the invoices returned will result from seeking backwards from the specified index offset. This can be used to paginate backwards. (optional)
      creationDateStart - If set, returns all invoices with a creation date greater than or equal to it. Measured in seconds since the unix epoch. (optional)
      creationDateEnd - If set, returns all invoices with a creation date less than or equal to it. Measured in seconds since the unix epoch. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • listMacaroonIDsCall

      public okhttp3.Call listMacaroonIDsCall(ApiCallback _callback) throws ApiException
      Build call for listMacaroonIDs
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • listMacaroonIDs

      public LnrpcListMacaroonIDsResponse listMacaroonIDs() throws ApiException
      lncli: `listmacaroonids` ListMacaroonIDs returns all root key IDs that are in use.
      Returns:
      LnrpcListMacaroonIDsResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listMacaroonIDsWithHttpInfo

      public ApiResponse<LnrpcListMacaroonIDsResponse> listMacaroonIDsWithHttpInfo() throws ApiException
      lncli: `listmacaroonids` ListMacaroonIDs returns all root key IDs that are in use.
      Returns:
      ApiResponse<LnrpcListMacaroonIDsResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listMacaroonIDsAsync

      public okhttp3.Call listMacaroonIDsAsync(ApiCallback<LnrpcListMacaroonIDsResponse> _callback) throws ApiException
      lncli: `listmacaroonids` ListMacaroonIDs returns all root key IDs that are in use. (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • listPaymentsCall

      public okhttp3.Call listPaymentsCall(Boolean includeIncomplete, String indexOffset, String maxPayments, Boolean reversed, Boolean countTotalPayments, String creationDateStart, String creationDateEnd, ApiCallback _callback) throws ApiException
      Build call for listPayments
      Parameters:
      includeIncomplete - If true, then return payments that have not yet fully completed. This means that pending payments, as well as failed payments will show up if this field is set to true. This flag doesn't change the meaning of the indices, which are tied to individual payments. (optional)
      indexOffset - The index of a payment that will be used as either the start or end of a query to determine which payments should be returned in the response. The index_offset is exclusive. In the case of a zero index_offset, the query will start with the oldest payment when paginating forwards, or will end with the most recent payment when paginating backwards. (optional)
      maxPayments - The maximal number of payments returned in the response to this query. (optional)
      reversed - If set, the payments returned will result from seeking backwards from the specified index offset. This can be used to paginate backwards. The order of the returned payments is always oldest first (ascending index order). (optional)
      countTotalPayments - If set, all payments (complete and incomplete, independent of the max_payments parameter) will be counted. Note that setting this to true will increase the run time of the call significantly on systems that have a lot of payments, as all of them have to be iterated through to be counted. (optional)
      creationDateStart - If set, returns all invoices with a creation date greater than or equal to it. Measured in seconds since the unix epoch. (optional)
      creationDateEnd - If set, returns all invoices with a creation date less than or equal to it. Measured in seconds since the unix epoch. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • listPayments

      public LnrpcListPaymentsResponse listPayments(Boolean includeIncomplete, String indexOffset, String maxPayments, Boolean reversed, Boolean countTotalPayments, String creationDateStart, String creationDateEnd) throws ApiException
      lncli: `listpayments` ListPayments returns a list of all outgoing payments.
      Parameters:
      includeIncomplete - If true, then return payments that have not yet fully completed. This means that pending payments, as well as failed payments will show up if this field is set to true. This flag doesn't change the meaning of the indices, which are tied to individual payments. (optional)
      indexOffset - The index of a payment that will be used as either the start or end of a query to determine which payments should be returned in the response. The index_offset is exclusive. In the case of a zero index_offset, the query will start with the oldest payment when paginating forwards, or will end with the most recent payment when paginating backwards. (optional)
      maxPayments - The maximal number of payments returned in the response to this query. (optional)
      reversed - If set, the payments returned will result from seeking backwards from the specified index offset. This can be used to paginate backwards. The order of the returned payments is always oldest first (ascending index order). (optional)
      countTotalPayments - If set, all payments (complete and incomplete, independent of the max_payments parameter) will be counted. Note that setting this to true will increase the run time of the call significantly on systems that have a lot of payments, as all of them have to be iterated through to be counted. (optional)
      creationDateStart - If set, returns all invoices with a creation date greater than or equal to it. Measured in seconds since the unix epoch. (optional)
      creationDateEnd - If set, returns all invoices with a creation date less than or equal to it. Measured in seconds since the unix epoch. (optional)
      Returns:
      LnrpcListPaymentsResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listPaymentsWithHttpInfo

      public ApiResponse<LnrpcListPaymentsResponse> listPaymentsWithHttpInfo(Boolean includeIncomplete, String indexOffset, String maxPayments, Boolean reversed, Boolean countTotalPayments, String creationDateStart, String creationDateEnd) throws ApiException
      lncli: `listpayments` ListPayments returns a list of all outgoing payments.
      Parameters:
      includeIncomplete - If true, then return payments that have not yet fully completed. This means that pending payments, as well as failed payments will show up if this field is set to true. This flag doesn't change the meaning of the indices, which are tied to individual payments. (optional)
      indexOffset - The index of a payment that will be used as either the start or end of a query to determine which payments should be returned in the response. The index_offset is exclusive. In the case of a zero index_offset, the query will start with the oldest payment when paginating forwards, or will end with the most recent payment when paginating backwards. (optional)
      maxPayments - The maximal number of payments returned in the response to this query. (optional)
      reversed - If set, the payments returned will result from seeking backwards from the specified index offset. This can be used to paginate backwards. The order of the returned payments is always oldest first (ascending index order). (optional)
      countTotalPayments - If set, all payments (complete and incomplete, independent of the max_payments parameter) will be counted. Note that setting this to true will increase the run time of the call significantly on systems that have a lot of payments, as all of them have to be iterated through to be counted. (optional)
      creationDateStart - If set, returns all invoices with a creation date greater than or equal to it. Measured in seconds since the unix epoch. (optional)
      creationDateEnd - If set, returns all invoices with a creation date less than or equal to it. Measured in seconds since the unix epoch. (optional)
      Returns:
      ApiResponse<LnrpcListPaymentsResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listPaymentsAsync

      public okhttp3.Call listPaymentsAsync(Boolean includeIncomplete, String indexOffset, String maxPayments, Boolean reversed, Boolean countTotalPayments, String creationDateStart, String creationDateEnd, ApiCallback<LnrpcListPaymentsResponse> _callback) throws ApiException
      lncli: `listpayments` ListPayments returns a list of all outgoing payments. (asynchronously)
      Parameters:
      includeIncomplete - If true, then return payments that have not yet fully completed. This means that pending payments, as well as failed payments will show up if this field is set to true. This flag doesn't change the meaning of the indices, which are tied to individual payments. (optional)
      indexOffset - The index of a payment that will be used as either the start or end of a query to determine which payments should be returned in the response. The index_offset is exclusive. In the case of a zero index_offset, the query will start with the oldest payment when paginating forwards, or will end with the most recent payment when paginating backwards. (optional)
      maxPayments - The maximal number of payments returned in the response to this query. (optional)
      reversed - If set, the payments returned will result from seeking backwards from the specified index offset. This can be used to paginate backwards. The order of the returned payments is always oldest first (ascending index order). (optional)
      countTotalPayments - If set, all payments (complete and incomplete, independent of the max_payments parameter) will be counted. Note that setting this to true will increase the run time of the call significantly on systems that have a lot of payments, as all of them have to be iterated through to be counted. (optional)
      creationDateStart - If set, returns all invoices with a creation date greater than or equal to it. Measured in seconds since the unix epoch. (optional)
      creationDateEnd - If set, returns all invoices with a creation date less than or equal to it. Measured in seconds since the unix epoch. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • listPeersCall

      public okhttp3.Call listPeersCall(Boolean latestError, ApiCallback _callback) throws ApiException
      Build call for listPeers
      Parameters:
      latestError - If true, only the last error that our peer sent us will be returned with the peer's information, rather than the full set of historic errors we have stored. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • listPeers

      public LnrpcListPeersResponse listPeers(Boolean latestError) throws ApiException
      lncli: `listpeers` ListPeers returns a verbose listing of all currently active peers.
      Parameters:
      latestError - If true, only the last error that our peer sent us will be returned with the peer's information, rather than the full set of historic errors we have stored. (optional)
      Returns:
      LnrpcListPeersResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listPeersWithHttpInfo

      public ApiResponse<LnrpcListPeersResponse> listPeersWithHttpInfo(Boolean latestError) throws ApiException
      lncli: `listpeers` ListPeers returns a verbose listing of all currently active peers.
      Parameters:
      latestError - If true, only the last error that our peer sent us will be returned with the peer's information, rather than the full set of historic errors we have stored. (optional)
      Returns:
      ApiResponse<LnrpcListPeersResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listPeersAsync

      public okhttp3.Call listPeersAsync(Boolean latestError, ApiCallback<LnrpcListPeersResponse> _callback) throws ApiException
      lncli: `listpeers` ListPeers returns a verbose listing of all currently active peers. (asynchronously)
      Parameters:
      latestError - If true, only the last error that our peer sent us will be returned with the peer's information, rather than the full set of historic errors we have stored. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • listPermissionsCall

      public okhttp3.Call listPermissionsCall(ApiCallback _callback) throws ApiException
      Build call for listPermissions
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • listPermissions

      public LnrpcListPermissionsResponse listPermissions() throws ApiException
      lncli: `listpermissions` ListPermissions lists all RPC method URIs and their required macaroon permissions to access them.
      Returns:
      LnrpcListPermissionsResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listPermissionsWithHttpInfo

      public ApiResponse<LnrpcListPermissionsResponse> listPermissionsWithHttpInfo() throws ApiException
      lncli: `listpermissions` ListPermissions lists all RPC method URIs and their required macaroon permissions to access them.
      Returns:
      ApiResponse<LnrpcListPermissionsResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listPermissionsAsync

      public okhttp3.Call listPermissionsAsync(ApiCallback<LnrpcListPermissionsResponse> _callback) throws ApiException
      lncli: `listpermissions` ListPermissions lists all RPC method URIs and their required macaroon permissions to access them. (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • listUnspentCall

      public okhttp3.Call listUnspentCall(Integer minConfs, Integer maxConfs, String account, ApiCallback _callback) throws ApiException
      Build call for listUnspent
      Parameters:
      minConfs - The minimum number of confirmations to be included. (optional)
      maxConfs - The maximum number of confirmations to be included. (optional)
      account - An optional filter to only include outputs belonging to an account. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • listUnspent

      public LnrpcListUnspentResponse listUnspent(Integer minConfs, Integer maxConfs, String account) throws ApiException
      lncli: `listunspent` Deprecated, use walletrpc.ListUnspent instead. ListUnspent returns a list of all utxos spendable by the wallet with a number of confirmations between the specified minimum and maximum.
      Parameters:
      minConfs - The minimum number of confirmations to be included. (optional)
      maxConfs - The maximum number of confirmations to be included. (optional)
      account - An optional filter to only include outputs belonging to an account. (optional)
      Returns:
      LnrpcListUnspentResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listUnspentWithHttpInfo

      public ApiResponse<LnrpcListUnspentResponse> listUnspentWithHttpInfo(Integer minConfs, Integer maxConfs, String account) throws ApiException
      lncli: `listunspent` Deprecated, use walletrpc.ListUnspent instead. ListUnspent returns a list of all utxos spendable by the wallet with a number of confirmations between the specified minimum and maximum.
      Parameters:
      minConfs - The minimum number of confirmations to be included. (optional)
      maxConfs - The maximum number of confirmations to be included. (optional)
      account - An optional filter to only include outputs belonging to an account. (optional)
      Returns:
      ApiResponse<LnrpcListUnspentResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • listUnspentAsync

      public okhttp3.Call listUnspentAsync(Integer minConfs, Integer maxConfs, String account, ApiCallback<LnrpcListUnspentResponse> _callback) throws ApiException
      lncli: `listunspent` Deprecated, use walletrpc.ListUnspent instead. (asynchronously) ListUnspent returns a list of all utxos spendable by the wallet with a number of confirmations between the specified minimum and maximum.
      Parameters:
      minConfs - The minimum number of confirmations to be included. (optional)
      maxConfs - The maximum number of confirmations to be included. (optional)
      account - An optional filter to only include outputs belonging to an account. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • lookupHtlcResolutionCall

      public okhttp3.Call lookupHtlcResolutionCall(String chanId, String htlcIndex, ApiCallback _callback) throws ApiException
      Build call for lookupHtlcResolution
      Parameters:
      chanId - (required)
      htlcIndex - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • lookupHtlcResolution

      public LnrpcLookupHtlcResolutionResponse lookupHtlcResolution(String chanId, String htlcIndex) throws ApiException
      LookupHtlcResolution retrieves a final htlc resolution from the database. If the htlc has no final resolution yet, a NotFound grpc status code is returned.
      Parameters:
      chanId - (required)
      htlcIndex - (required)
      Returns:
      LnrpcLookupHtlcResolutionResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • lookupHtlcResolutionWithHttpInfo

      public ApiResponse<LnrpcLookupHtlcResolutionResponse> lookupHtlcResolutionWithHttpInfo(String chanId, String htlcIndex) throws ApiException
      LookupHtlcResolution retrieves a final htlc resolution from the database. If the htlc has no final resolution yet, a NotFound grpc status code is returned.
      Parameters:
      chanId - (required)
      htlcIndex - (required)
      Returns:
      ApiResponse<LnrpcLookupHtlcResolutionResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • lookupHtlcResolutionAsync

      public okhttp3.Call lookupHtlcResolutionAsync(String chanId, String htlcIndex, ApiCallback<LnrpcLookupHtlcResolutionResponse> _callback) throws ApiException
      LookupHtlcResolution retrieves a final htlc resolution from the database. If the htlc has no final resolution yet, a NotFound grpc status code is returned. (asynchronously)
      Parameters:
      chanId - (required)
      htlcIndex - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • lookupInvoiceCall

      public okhttp3.Call lookupInvoiceCall(String rHashStr, byte[] rHash, ApiCallback _callback) throws ApiException
      Build call for lookupInvoice
      Parameters:
      rHashStr - 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. Deprecated now that the REST gateway supports base64 encoding of bytes fields. (required)
      rHash - The payment hash of the invoice to be looked up. When using REST, this field must be encoded as base64. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • lookupInvoice

      public LnrpcInvoice lookupInvoice(String rHashStr, byte[] rHash) throws ApiException
      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.
      Parameters:
      rHashStr - 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. Deprecated now that the REST gateway supports base64 encoding of bytes fields. (required)
      rHash - The payment hash of the invoice to be looked up. When using REST, this field must be encoded as base64. (optional)
      Returns:
      LnrpcInvoice
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • lookupInvoiceWithHttpInfo

      public ApiResponse<LnrpcInvoice> lookupInvoiceWithHttpInfo(String rHashStr, byte[] rHash) throws ApiException
      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.
      Parameters:
      rHashStr - 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. Deprecated now that the REST gateway supports base64 encoding of bytes fields. (required)
      rHash - The payment hash of the invoice to be looked up. When using REST, this field must be encoded as base64. (optional)
      Returns:
      ApiResponse<LnrpcInvoice>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • lookupInvoiceAsync

      public okhttp3.Call lookupInvoiceAsync(String rHashStr, byte[] rHash, ApiCallback<LnrpcInvoice> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      rHashStr - 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. Deprecated now that the REST gateway supports base64 encoding of bytes fields. (required)
      rHash - The payment hash of the invoice to be looked up. When using REST, this field must be encoded as base64. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • newAddressCall

      public okhttp3.Call newAddressCall(String type, String account, ApiCallback _callback) throws ApiException
      Build call for newAddress
      Parameters:
      type - The type of address to generate. (optional, default to WITNESS_PUBKEY_HASH)
      account - The name of the account to generate a new address for. If empty, the default wallet account is used. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • newAddress

      public LnrpcNewAddressResponse newAddress(String type, String account) throws ApiException
      lncli: `newaddress` NewAddress creates a new address under control of the local wallet.
      Parameters:
      type - The type of address to generate. (optional, default to WITNESS_PUBKEY_HASH)
      account - The name of the account to generate a new address for. If empty, the default wallet account is used. (optional)
      Returns:
      LnrpcNewAddressResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • newAddressWithHttpInfo

      public ApiResponse<LnrpcNewAddressResponse> newAddressWithHttpInfo(String type, String account) throws ApiException
      lncli: `newaddress` NewAddress creates a new address under control of the local wallet.
      Parameters:
      type - The type of address to generate. (optional, default to WITNESS_PUBKEY_HASH)
      account - The name of the account to generate a new address for. If empty, the default wallet account is used. (optional)
      Returns:
      ApiResponse<LnrpcNewAddressResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • newAddressAsync

      public okhttp3.Call newAddressAsync(String type, String account, ApiCallback<LnrpcNewAddressResponse> _callback) throws ApiException
      lncli: `newaddress` NewAddress creates a new address under control of the local wallet. (asynchronously)
      Parameters:
      type - The type of address to generate. (optional, default to WITNESS_PUBKEY_HASH)
      account - The name of the account to generate a new address for. If empty, the default wallet account is used. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • openChannelCall

      public okhttp3.Call openChannelCall(LnrpcOpenChannelRequest body, ApiCallback _callback) throws ApiException
      Build call for openChannel
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • openChannel

      public StreamResultOfLnrpcOpenStatusUpdate openChannel(LnrpcOpenChannelRequest body) throws ApiException
      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. Each OpenStatusUpdate will return the pending channel ID of the in-progress channel. Depending on the arguments specified in the OpenChannelRequest, this pending channel ID can then be used to manually progress the channel funding flow.
      Parameters:
      body - (required)
      Returns:
      StreamResultOfLnrpcOpenStatusUpdate
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • openChannelWithHttpInfo

      public ApiResponse<StreamResultOfLnrpcOpenStatusUpdate> openChannelWithHttpInfo(LnrpcOpenChannelRequest body) throws ApiException
      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. Each OpenStatusUpdate will return the pending channel ID of the in-progress channel. Depending on the arguments specified in the OpenChannelRequest, this pending channel ID can then be used to manually progress the channel funding flow.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<StreamResultOfLnrpcOpenStatusUpdate>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • openChannelAsync

      public okhttp3.Call openChannelAsync(LnrpcOpenChannelRequest body, ApiCallback<StreamResultOfLnrpcOpenStatusUpdate> _callback) throws ApiException
      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. Each OpenStatusUpdate will return the pending channel ID of the in-progress channel. Depending on the arguments specified in the OpenChannelRequest, this pending channel ID can then be used to manually progress the channel funding flow. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • openChannelSyncCall

      public okhttp3.Call openChannelSyncCall(LnrpcOpenChannelRequest body, ApiCallback _callback) throws ApiException
      Build call for openChannelSync
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • openChannelSync

      public LnrpcChannelPoint openChannelSync(LnrpcOpenChannelRequest body) throws ApiException
      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.
      Parameters:
      body - (required)
      Returns:
      LnrpcChannelPoint
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • openChannelSyncWithHttpInfo

      public ApiResponse<LnrpcChannelPoint> openChannelSyncWithHttpInfo(LnrpcOpenChannelRequest body) throws ApiException
      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.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<LnrpcChannelPoint>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • openChannelSyncAsync

      public okhttp3.Call openChannelSyncAsync(LnrpcOpenChannelRequest body, ApiCallback<LnrpcChannelPoint> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • pendingChannelsCall

      public okhttp3.Call pendingChannelsCall(ApiCallback _callback) throws ApiException
      Build call for pendingChannels
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • pendingChannels

      public LnrpcPendingChannelsResponse pendingChannels() throws ApiException
      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.
      Returns:
      LnrpcPendingChannelsResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • pendingChannelsWithHttpInfo

      public ApiResponse<LnrpcPendingChannelsResponse> pendingChannelsWithHttpInfo() throws ApiException
      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.
      Returns:
      ApiResponse<LnrpcPendingChannelsResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • pendingChannelsAsync

      public okhttp3.Call pendingChannelsAsync(ApiCallback<LnrpcPendingChannelsResponse> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • queryRoutesCall

      public okhttp3.Call queryRoutesCall(String pubKey, String amt, String amtMsat, Integer finalCltvDelta, String feeLimitFixed, String feeLimitFixedMsat, String feeLimitPercent, List<byte[]> ignoredNodes, String sourcePubKey, Boolean useMissionControl, Long cltvLimit, String outgoingChanId, byte[] lastHopPubkey, List<String> destFeatures, Double timePref, ApiCallback _callback) throws ApiException
      Build call for queryRoutes
      Parameters:
      pubKey - The 33-byte hex-encoded public key for the payment destination (required)
      amt - The amount to send expressed in satoshis. The fields amt and amt_msat are mutually exclusive. (required)
      amtMsat - The amount to send expressed in millisatoshis. The fields amt and amt_msat are mutually exclusive. (optional)
      finalCltvDelta - An optional CLTV delta from the current height that should be used for the timelock of the final hop. Note that unlike SendPayment, QueryRoutes does not add any additional block padding on top of final_ctlv_delta. This padding of a few blocks needs to be added manually or otherwise failures may happen when a block comes in while the payment is in flight. (optional)
      feeLimitFixed - The fee limit expressed as a fixed amount of satoshis. The fields fixed and fixed_msat are mutually exclusive. (optional)
      feeLimitFixedMsat - The fee limit expressed as a fixed amount of millisatoshis. The fields fixed and fixed_msat are mutually exclusive. (optional)
      feeLimitPercent - The fee limit expressed as a percentage of the payment amount. (optional)
      ignoredNodes - A list of nodes to ignore during path finding. When using REST, these fields must be encoded as base64. (optional)
      sourcePubKey - The source node where the request route should originated from. If empty, self is assumed. (optional)
      useMissionControl - If set to true, edge probabilities from mission control will be used to get the optimal route. (optional)
      cltvLimit - An optional maximum total time lock for the route. If the source is empty or ourselves, this should not exceed lnd's `--max-cltv-expiry` setting. If zero, then the value of `--max-cltv-expiry` is used as the limit. (optional)
      outgoingChanId - The channel id of the channel that must be taken to the first hop. If zero, any channel may be used. (optional)
      lastHopPubkey - The pubkey of the last hop of the route. If empty, any hop may be used. (optional)
      destFeatures - Features assumed to be supported by the final node. All transitive feature dependencies must also be set properly. For a given feature bit pair, either optional or remote may be set, but not both. If this field is nil or empty, the router will try to load destination features from the graph as a fallback. (optional)
      timePref - The time preference for this payment. Set to -1 to optimize for fees only, to 1 to optimize for reliability only or a value inbetween for a mix. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • queryRoutes

      public LnrpcQueryRoutesResponse queryRoutes(String pubKey, String amt, String amtMsat, Integer finalCltvDelta, String feeLimitFixed, String feeLimitFixedMsat, String feeLimitPercent, List<byte[]> ignoredNodes, String sourcePubKey, Boolean useMissionControl, Long cltvLimit, String outgoingChanId, byte[] lastHopPubkey, List<String> destFeatures, Double timePref) throws ApiException
      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 returned 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. When using REST, the `dest_custom_records` map type can be set by appending `&dest_custom_records[<record_number>]=<record_data_base64_url_encoded>` to the URL. Unfortunately this map type doesn't appear in the REST API documentation because of a bug in the grpc-gateway library.
      Parameters:
      pubKey - The 33-byte hex-encoded public key for the payment destination (required)
      amt - The amount to send expressed in satoshis. The fields amt and amt_msat are mutually exclusive. (required)
      amtMsat - The amount to send expressed in millisatoshis. The fields amt and amt_msat are mutually exclusive. (optional)
      finalCltvDelta - An optional CLTV delta from the current height that should be used for the timelock of the final hop. Note that unlike SendPayment, QueryRoutes does not add any additional block padding on top of final_ctlv_delta. This padding of a few blocks needs to be added manually or otherwise failures may happen when a block comes in while the payment is in flight. (optional)
      feeLimitFixed - The fee limit expressed as a fixed amount of satoshis. The fields fixed and fixed_msat are mutually exclusive. (optional)
      feeLimitFixedMsat - The fee limit expressed as a fixed amount of millisatoshis. The fields fixed and fixed_msat are mutually exclusive. (optional)
      feeLimitPercent - The fee limit expressed as a percentage of the payment amount. (optional)
      ignoredNodes - A list of nodes to ignore during path finding. When using REST, these fields must be encoded as base64. (optional)
      sourcePubKey - The source node where the request route should originated from. If empty, self is assumed. (optional)
      useMissionControl - If set to true, edge probabilities from mission control will be used to get the optimal route. (optional)
      cltvLimit - An optional maximum total time lock for the route. If the source is empty or ourselves, this should not exceed lnd's `--max-cltv-expiry` setting. If zero, then the value of `--max-cltv-expiry` is used as the limit. (optional)
      outgoingChanId - The channel id of the channel that must be taken to the first hop. If zero, any channel may be used. (optional)
      lastHopPubkey - The pubkey of the last hop of the route. If empty, any hop may be used. (optional)
      destFeatures - Features assumed to be supported by the final node. All transitive feature dependencies must also be set properly. For a given feature bit pair, either optional or remote may be set, but not both. If this field is nil or empty, the router will try to load destination features from the graph as a fallback. (optional)
      timePref - The time preference for this payment. Set to -1 to optimize for fees only, to 1 to optimize for reliability only or a value inbetween for a mix. (optional)
      Returns:
      LnrpcQueryRoutesResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • queryRoutesWithHttpInfo

      public ApiResponse<LnrpcQueryRoutesResponse> queryRoutesWithHttpInfo(String pubKey, String amt, String amtMsat, Integer finalCltvDelta, String feeLimitFixed, String feeLimitFixedMsat, String feeLimitPercent, List<byte[]> ignoredNodes, String sourcePubKey, Boolean useMissionControl, Long cltvLimit, String outgoingChanId, byte[] lastHopPubkey, List<String> destFeatures, Double timePref) throws ApiException
      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 returned 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. When using REST, the `dest_custom_records` map type can be set by appending `&dest_custom_records[<record_number>]=<record_data_base64_url_encoded>` to the URL. Unfortunately this map type doesn't appear in the REST API documentation because of a bug in the grpc-gateway library.
      Parameters:
      pubKey - The 33-byte hex-encoded public key for the payment destination (required)
      amt - The amount to send expressed in satoshis. The fields amt and amt_msat are mutually exclusive. (required)
      amtMsat - The amount to send expressed in millisatoshis. The fields amt and amt_msat are mutually exclusive. (optional)
      finalCltvDelta - An optional CLTV delta from the current height that should be used for the timelock of the final hop. Note that unlike SendPayment, QueryRoutes does not add any additional block padding on top of final_ctlv_delta. This padding of a few blocks needs to be added manually or otherwise failures may happen when a block comes in while the payment is in flight. (optional)
      feeLimitFixed - The fee limit expressed as a fixed amount of satoshis. The fields fixed and fixed_msat are mutually exclusive. (optional)
      feeLimitFixedMsat - The fee limit expressed as a fixed amount of millisatoshis. The fields fixed and fixed_msat are mutually exclusive. (optional)
      feeLimitPercent - The fee limit expressed as a percentage of the payment amount. (optional)
      ignoredNodes - A list of nodes to ignore during path finding. When using REST, these fields must be encoded as base64. (optional)
      sourcePubKey - The source node where the request route should originated from. If empty, self is assumed. (optional)
      useMissionControl - If set to true, edge probabilities from mission control will be used to get the optimal route. (optional)
      cltvLimit - An optional maximum total time lock for the route. If the source is empty or ourselves, this should not exceed lnd's `--max-cltv-expiry` setting. If zero, then the value of `--max-cltv-expiry` is used as the limit. (optional)
      outgoingChanId - The channel id of the channel that must be taken to the first hop. If zero, any channel may be used. (optional)
      lastHopPubkey - The pubkey of the last hop of the route. If empty, any hop may be used. (optional)
      destFeatures - Features assumed to be supported by the final node. All transitive feature dependencies must also be set properly. For a given feature bit pair, either optional or remote may be set, but not both. If this field is nil or empty, the router will try to load destination features from the graph as a fallback. (optional)
      timePref - The time preference for this payment. Set to -1 to optimize for fees only, to 1 to optimize for reliability only or a value inbetween for a mix. (optional)
      Returns:
      ApiResponse<LnrpcQueryRoutesResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • queryRoutesAsync

      public okhttp3.Call queryRoutesAsync(String pubKey, String amt, String amtMsat, Integer finalCltvDelta, String feeLimitFixed, String feeLimitFixedMsat, String feeLimitPercent, List<byte[]> ignoredNodes, String sourcePubKey, Boolean useMissionControl, Long cltvLimit, String outgoingChanId, byte[] lastHopPubkey, List<String> destFeatures, Double timePref, ApiCallback<LnrpcQueryRoutesResponse> _callback) throws ApiException
      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 returned 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. (asynchronously) When using REST, the `dest_custom_records` map type can be set by appending `&dest_custom_records[<record_number>]=<record_data_base64_url_encoded>` to the URL. Unfortunately this map type doesn't appear in the REST API documentation because of a bug in the grpc-gateway library.
      Parameters:
      pubKey - The 33-byte hex-encoded public key for the payment destination (required)
      amt - The amount to send expressed in satoshis. The fields amt and amt_msat are mutually exclusive. (required)
      amtMsat - The amount to send expressed in millisatoshis. The fields amt and amt_msat are mutually exclusive. (optional)
      finalCltvDelta - An optional CLTV delta from the current height that should be used for the timelock of the final hop. Note that unlike SendPayment, QueryRoutes does not add any additional block padding on top of final_ctlv_delta. This padding of a few blocks needs to be added manually or otherwise failures may happen when a block comes in while the payment is in flight. (optional)
      feeLimitFixed - The fee limit expressed as a fixed amount of satoshis. The fields fixed and fixed_msat are mutually exclusive. (optional)
      feeLimitFixedMsat - The fee limit expressed as a fixed amount of millisatoshis. The fields fixed and fixed_msat are mutually exclusive. (optional)
      feeLimitPercent - The fee limit expressed as a percentage of the payment amount. (optional)
      ignoredNodes - A list of nodes to ignore during path finding. When using REST, these fields must be encoded as base64. (optional)
      sourcePubKey - The source node where the request route should originated from. If empty, self is assumed. (optional)
      useMissionControl - If set to true, edge probabilities from mission control will be used to get the optimal route. (optional)
      cltvLimit - An optional maximum total time lock for the route. If the source is empty or ourselves, this should not exceed lnd's `--max-cltv-expiry` setting. If zero, then the value of `--max-cltv-expiry` is used as the limit. (optional)
      outgoingChanId - The channel id of the channel that must be taken to the first hop. If zero, any channel may be used. (optional)
      lastHopPubkey - The pubkey of the last hop of the route. If empty, any hop may be used. (optional)
      destFeatures - Features assumed to be supported by the final node. All transitive feature dependencies must also be set properly. For a given feature bit pair, either optional or remote may be set, but not both. If this field is nil or empty, the router will try to load destination features from the graph as a fallback. (optional)
      timePref - The time preference for this payment. Set to -1 to optimize for fees only, to 1 to optimize for reliability only or a value inbetween for a mix. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • queryRoutes2Call

      public okhttp3.Call queryRoutes2Call(String pubKey, String amt, InlineObject body, ApiCallback _callback) throws ApiException
      Build call for queryRoutes2
      Parameters:
      pubKey - The 33-byte hex-encoded public key for the payment destination (required)
      amt - The amount to send expressed in satoshis. The fields amt and amt_msat are mutually exclusive. (required)
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • queryRoutes2

      public LnrpcQueryRoutesResponse queryRoutes2(String pubKey, String amt, InlineObject body) throws ApiException
      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 returned 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. When using REST, the `dest_custom_records` map type can be set by appending `&dest_custom_records[<record_number>]=<record_data_base64_url_encoded>` to the URL. Unfortunately this map type doesn't appear in the REST API documentation because of a bug in the grpc-gateway library.
      Parameters:
      pubKey - The 33-byte hex-encoded public key for the payment destination (required)
      amt - The amount to send expressed in satoshis. The fields amt and amt_msat are mutually exclusive. (required)
      body - (required)
      Returns:
      LnrpcQueryRoutesResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • queryRoutes2WithHttpInfo

      public ApiResponse<LnrpcQueryRoutesResponse> queryRoutes2WithHttpInfo(String pubKey, String amt, InlineObject body) throws ApiException
      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 returned 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. When using REST, the `dest_custom_records` map type can be set by appending `&dest_custom_records[<record_number>]=<record_data_base64_url_encoded>` to the URL. Unfortunately this map type doesn't appear in the REST API documentation because of a bug in the grpc-gateway library.
      Parameters:
      pubKey - The 33-byte hex-encoded public key for the payment destination (required)
      amt - The amount to send expressed in satoshis. The fields amt and amt_msat are mutually exclusive. (required)
      body - (required)
      Returns:
      ApiResponse<LnrpcQueryRoutesResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • queryRoutes2Async

      public okhttp3.Call queryRoutes2Async(String pubKey, String amt, InlineObject body, ApiCallback<LnrpcQueryRoutesResponse> _callback) throws ApiException
      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 returned 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. (asynchronously) When using REST, the `dest_custom_records` map type can be set by appending `&dest_custom_records[<record_number>]=<record_data_base64_url_encoded>` to the URL. Unfortunately this map type doesn't appear in the REST API documentation because of a bug in the grpc-gateway library.
      Parameters:
      pubKey - The 33-byte hex-encoded public key for the payment destination (required)
      amt - The amount to send expressed in satoshis. The fields amt and amt_msat are mutually exclusive. (required)
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • registerRPCMiddlewareCall

      public okhttp3.Call registerRPCMiddlewareCall(ApiCallback _callback) throws ApiException
      Build call for registerRPCMiddleware
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • registerRPCMiddleware

      public StreamResultOfLnrpcRPCMiddlewareRequest registerRPCMiddleware() throws ApiException
      RegisterRPCMiddleware adds a new gRPC middleware to the interceptor chain. A gRPC middleware is software component external to lnd that aims to add additional business logic to lnd by observing/intercepting/validating incoming gRPC client requests and (if needed) replacing/overwriting outgoing messages before they're sent to the client. When registering the middleware must identify itself and indicate what custom macaroon caveats it wants to be responsible for. Only requests that contain a macaroon with that specific custom caveat are then sent to the middleware for inspection. The other option is to register for the read-only mode in which all requests/responses are forwarded for interception to the middleware but the middleware is not allowed to modify any responses. As a security measure, _no_ middleware can modify responses for requests made with _unencumbered_ macaroons!
      Returns:
      StreamResultOfLnrpcRPCMiddlewareRequest
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • registerRPCMiddlewareWithHttpInfo

      public ApiResponse<StreamResultOfLnrpcRPCMiddlewareRequest> registerRPCMiddlewareWithHttpInfo() throws ApiException
      RegisterRPCMiddleware adds a new gRPC middleware to the interceptor chain. A gRPC middleware is software component external to lnd that aims to add additional business logic to lnd by observing/intercepting/validating incoming gRPC client requests and (if needed) replacing/overwriting outgoing messages before they're sent to the client. When registering the middleware must identify itself and indicate what custom macaroon caveats it wants to be responsible for. Only requests that contain a macaroon with that specific custom caveat are then sent to the middleware for inspection. The other option is to register for the read-only mode in which all requests/responses are forwarded for interception to the middleware but the middleware is not allowed to modify any responses. As a security measure, _no_ middleware can modify responses for requests made with _unencumbered_ macaroons!
      Returns:
      ApiResponse<StreamResultOfLnrpcRPCMiddlewareRequest>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • registerRPCMiddlewareAsync

      public okhttp3.Call registerRPCMiddlewareAsync(ApiCallback<StreamResultOfLnrpcRPCMiddlewareRequest> _callback) throws ApiException
      RegisterRPCMiddleware adds a new gRPC middleware to the interceptor chain. A gRPC middleware is software component external to lnd that aims to add additional business logic to lnd by observing/intercepting/validating incoming gRPC client requests and (if needed) replacing/overwriting outgoing messages before they're sent to the client. When registering the middleware must identify itself and indicate what custom macaroon caveats it wants to be responsible for. Only requests that contain a macaroon with that specific custom caveat are then sent to the middleware for inspection. The other option is to register for the read-only mode in which all requests/responses are forwarded for interception to the middleware but the middleware is not allowed to modify any responses. As a security measure, _no_ middleware can modify responses for requests made with _unencumbered_ macaroons! (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • restoreChannelBackupsCall

      public okhttp3.Call restoreChannelBackupsCall(LnrpcRestoreChanBackupRequest body, ApiCallback _callback) throws ApiException
      Build call for restoreChannelBackups
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • restoreChannelBackups

      public Object restoreChannelBackups(LnrpcRestoreChanBackupRequest body) throws ApiException
      lncli: `restorechanbackup` RestoreChannelBackups accepts a set of singular channel backups, or a single encrypted multi-chan backup and attempts to recover any funds remaining within the channel. If we are able to unpack the backup, then the new channel will be shown under listchannels, as well as pending channels.
      Parameters:
      body - (required)
      Returns:
      Object
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • restoreChannelBackupsWithHttpInfo

      public ApiResponse<Object> restoreChannelBackupsWithHttpInfo(LnrpcRestoreChanBackupRequest body) throws ApiException
      lncli: `restorechanbackup` RestoreChannelBackups accepts a set of singular channel backups, or a single encrypted multi-chan backup and attempts to recover any funds remaining within the channel. If we are able to unpack the backup, then the new channel will be shown under listchannels, as well as pending channels.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<Object>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • restoreChannelBackupsAsync

      public okhttp3.Call restoreChannelBackupsAsync(LnrpcRestoreChanBackupRequest body, ApiCallback<Object> _callback) throws ApiException
      lncli: `restorechanbackup` RestoreChannelBackups accepts a set of singular channel backups, or a single encrypted multi-chan backup and attempts to recover any funds remaining within the channel. If we are able to unpack the backup, then the new channel will be shown under listchannels, as well as pending channels. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • sendCoinsCall

      public okhttp3.Call sendCoinsCall(LnrpcSendCoinsRequest body, ApiCallback _callback) throws ApiException
      Build call for sendCoins
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • sendCoins

      public LnrpcSendCoinsResponse sendCoins(LnrpcSendCoinsRequest body) throws ApiException
      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_vbyte are set, then the internal wallet will consult its fee model to determine a fee for the default confirmation target.
      Parameters:
      body - (required)
      Returns:
      LnrpcSendCoinsResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • sendCoinsWithHttpInfo

      public ApiResponse<LnrpcSendCoinsResponse> sendCoinsWithHttpInfo(LnrpcSendCoinsRequest body) throws ApiException
      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_vbyte are set, then the internal wallet will consult its fee model to determine a fee for the default confirmation target.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<LnrpcSendCoinsResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • sendCoinsAsync

      public okhttp3.Call sendCoinsAsync(LnrpcSendCoinsRequest body, ApiCallback<LnrpcSendCoinsResponse> _callback) throws ApiException
      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_vbyte are set, then the internal wallet will consult its fee model to determine a fee for the default confirmation target. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • sendCustomMessageCall

      public okhttp3.Call sendCustomMessageCall(LnrpcSendCustomMessageRequest body, ApiCallback _callback) throws ApiException
      Build call for sendCustomMessage
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • sendCustomMessage

      public Object sendCustomMessage(LnrpcSendCustomMessageRequest body) throws ApiException
      lncli: `sendcustom` SendCustomMessage sends a custom peer message.
      Parameters:
      body - (required)
      Returns:
      Object
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • sendCustomMessageWithHttpInfo

      public ApiResponse<Object> sendCustomMessageWithHttpInfo(LnrpcSendCustomMessageRequest body) throws ApiException
      lncli: `sendcustom` SendCustomMessage sends a custom peer message.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<Object>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • sendCustomMessageAsync

      public okhttp3.Call sendCustomMessageAsync(LnrpcSendCustomMessageRequest body, ApiCallback<Object> _callback) throws ApiException
      lncli: `sendcustom` SendCustomMessage sends a custom peer message. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • sendManyCall

      public okhttp3.Call sendManyCall(LnrpcSendManyRequest body, ApiCallback _callback) throws ApiException
      Build call for sendMany
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • sendMany

      public LnrpcSendManyResponse sendMany(LnrpcSendManyRequest body) throws ApiException
      lncli: `sendmany` SendMany handles a request for a transaction that creates multiple specified outputs in parallel. If neither target_conf, or sat_per_vbyte are set, then the internal wallet will consult its fee model to determine a fee for the default confirmation target.
      Parameters:
      body - (required)
      Returns:
      LnrpcSendManyResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • sendManyWithHttpInfo

      public ApiResponse<LnrpcSendManyResponse> sendManyWithHttpInfo(LnrpcSendManyRequest body) throws ApiException
      lncli: `sendmany` SendMany handles a request for a transaction that creates multiple specified outputs in parallel. If neither target_conf, or sat_per_vbyte are set, then the internal wallet will consult its fee model to determine a fee for the default confirmation target.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<LnrpcSendManyResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • sendManyAsync

      public okhttp3.Call sendManyAsync(LnrpcSendManyRequest body, ApiCallback<LnrpcSendManyResponse> _callback) throws ApiException
      lncli: `sendmany` SendMany handles a request for a transaction that creates multiple specified outputs in parallel. If neither target_conf, or sat_per_vbyte are set, then the internal wallet will consult its fee model to determine a fee for the default confirmation target. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • sendPaymentCall

      public okhttp3.Call sendPaymentCall(LnrpcSendRequest body, ApiCallback _callback) throws ApiException
      Build call for sendPayment
      Parameters:
      body - (streaming inputs) (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • sendPayment

      public StreamResultOfLnrpcSendResponse sendPayment(LnrpcSendRequest body) throws ApiException
      lncli: `sendpayment` Deprecated, use routerrpc.SendPaymentV2. 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.
      Parameters:
      body - (streaming inputs) (required)
      Returns:
      StreamResultOfLnrpcSendResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • sendPaymentWithHttpInfo

      public ApiResponse<StreamResultOfLnrpcSendResponse> sendPaymentWithHttpInfo(LnrpcSendRequest body) throws ApiException
      lncli: `sendpayment` Deprecated, use routerrpc.SendPaymentV2. 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.
      Parameters:
      body - (streaming inputs) (required)
      Returns:
      ApiResponse<StreamResultOfLnrpcSendResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • sendPaymentAsync

      public okhttp3.Call sendPaymentAsync(LnrpcSendRequest body, ApiCallback<StreamResultOfLnrpcSendResponse> _callback) throws ApiException
      lncli: `sendpayment` Deprecated, use routerrpc.SendPaymentV2. 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. (asynchronously)
      Parameters:
      body - (streaming inputs) (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • sendPaymentSyncCall

      public okhttp3.Call sendPaymentSyncCall(LnrpcSendRequest body, ApiCallback _callback) throws ApiException
      Build call for sendPaymentSync
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • sendPaymentSync

      public LnrpcSendResponse sendPaymentSync(LnrpcSendRequest body) throws ApiException
      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:
      body - (required)
      Returns:
      LnrpcSendResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • sendPaymentSyncWithHttpInfo

      public ApiResponse<LnrpcSendResponse> sendPaymentSyncWithHttpInfo(LnrpcSendRequest body) throws ApiException
      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:
      body - (required)
      Returns:
      ApiResponse<LnrpcSendResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • sendPaymentSyncAsync

      public okhttp3.Call sendPaymentSyncAsync(LnrpcSendRequest body, ApiCallback<LnrpcSendResponse> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • sendToRouteSyncCall

      public okhttp3.Call sendToRouteSyncCall(LnrpcSendToRouteRequest body, ApiCallback _callback) throws ApiException
      Build call for sendToRouteSync
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • sendToRouteSync

      public LnrpcSendResponse sendToRouteSync(LnrpcSendToRouteRequest body) throws ApiException
      SendToRouteSync is a synchronous version of SendToRoute. It Will block until the payment either fails or succeeds.
      Parameters:
      body - (required)
      Returns:
      LnrpcSendResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • sendToRouteSyncWithHttpInfo

      public ApiResponse<LnrpcSendResponse> sendToRouteSyncWithHttpInfo(LnrpcSendToRouteRequest body) throws ApiException
      SendToRouteSync is a synchronous version of SendToRoute. It Will block until the payment either fails or succeeds.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<LnrpcSendResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • sendToRouteSyncAsync

      public okhttp3.Call sendToRouteSyncAsync(LnrpcSendToRouteRequest body, ApiCallback<LnrpcSendResponse> _callback) throws ApiException
      SendToRouteSync is a synchronous version of SendToRoute. It Will block until the payment either fails or succeeds. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • signMessageCall

      public okhttp3.Call signMessageCall(LnrpcSignMessageRequest body, ApiCallback _callback) throws ApiException
      Build call for signMessage
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • signMessage

      public LnrpcSignMessageResponse signMessage(LnrpcSignMessageRequest body) throws ApiException
      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.
      Parameters:
      body - (required)
      Returns:
      LnrpcSignMessageResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • signMessageWithHttpInfo

      public ApiResponse<LnrpcSignMessageResponse> signMessageWithHttpInfo(LnrpcSignMessageRequest body) throws ApiException
      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.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<LnrpcSignMessageResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • signMessageAsync

      public okhttp3.Call signMessageAsync(LnrpcSignMessageRequest body, ApiCallback<LnrpcSignMessageResponse> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • stopDaemonCall

      public okhttp3.Call stopDaemonCall(Object body, ApiCallback _callback) throws ApiException
      Build call for stopDaemon
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • stopDaemon

      public Object stopDaemon(Object body) throws ApiException
      lncli: `stop` StopDaemon will send a shutdown request to the interrupt handler, triggering a graceful shutdown of the daemon.
      Parameters:
      body - (required)
      Returns:
      Object
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • stopDaemonWithHttpInfo

      public ApiResponse<Object> stopDaemonWithHttpInfo(Object body) throws ApiException
      lncli: `stop` StopDaemon will send a shutdown request to the interrupt handler, triggering a graceful shutdown of the daemon.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<Object>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • stopDaemonAsync

      public okhttp3.Call stopDaemonAsync(Object body, ApiCallback<Object> _callback) throws ApiException
      lncli: `stop` StopDaemon will send a shutdown request to the interrupt handler, triggering a graceful shutdown of the daemon. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • subscribeChannelBackupsCall

      public okhttp3.Call subscribeChannelBackupsCall(ApiCallback _callback) throws ApiException
      Build call for subscribeChannelBackups
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • subscribeChannelBackups

      public StreamResultOfLnrpcChanBackupSnapshot subscribeChannelBackups() throws ApiException
      SubscribeChannelBackups allows a client to sub-subscribe to the most up to date information concerning the state of all channel backups. Each time a new channel is added, we return the new set of channels, along with a multi-chan backup containing the backup info for all channels. Each time a channel is closed, we send a new update, which contains new new chan back ups, but the updated set of encrypted multi-chan backups with the closed channel(s) removed.
      Returns:
      StreamResultOfLnrpcChanBackupSnapshot
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • subscribeChannelBackupsWithHttpInfo

      public ApiResponse<StreamResultOfLnrpcChanBackupSnapshot> subscribeChannelBackupsWithHttpInfo() throws ApiException
      SubscribeChannelBackups allows a client to sub-subscribe to the most up to date information concerning the state of all channel backups. Each time a new channel is added, we return the new set of channels, along with a multi-chan backup containing the backup info for all channels. Each time a channel is closed, we send a new update, which contains new new chan back ups, but the updated set of encrypted multi-chan backups with the closed channel(s) removed.
      Returns:
      ApiResponse<StreamResultOfLnrpcChanBackupSnapshot>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • subscribeChannelBackupsAsync

      public okhttp3.Call subscribeChannelBackupsAsync(ApiCallback<StreamResultOfLnrpcChanBackupSnapshot> _callback) throws ApiException
      SubscribeChannelBackups allows a client to sub-subscribe to the most up to date information concerning the state of all channel backups. Each time a new channel is added, we return the new set of channels, along with a multi-chan backup containing the backup info for all channels. Each time a channel is closed, we send a new update, which contains new new chan back ups, but the updated set of encrypted multi-chan backups with the closed channel(s) removed. (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • subscribeChannelEventsCall

      public okhttp3.Call subscribeChannelEventsCall(ApiCallback _callback) throws ApiException
      Build call for subscribeChannelEvents
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • subscribeChannelEvents

      public StreamResultOfLnrpcChannelEventUpdate subscribeChannelEvents() throws ApiException
      SubscribeChannelEvents creates a uni-directional stream from the server to the client in which any updates relevant to the state of the channels are sent over. Events include new active channels, inactive channels, and closed channels.
      Returns:
      StreamResultOfLnrpcChannelEventUpdate
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • subscribeChannelEventsWithHttpInfo

      public ApiResponse<StreamResultOfLnrpcChannelEventUpdate> subscribeChannelEventsWithHttpInfo() throws ApiException
      SubscribeChannelEvents creates a uni-directional stream from the server to the client in which any updates relevant to the state of the channels are sent over. Events include new active channels, inactive channels, and closed channels.
      Returns:
      ApiResponse<StreamResultOfLnrpcChannelEventUpdate>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • subscribeChannelEventsAsync

      public okhttp3.Call subscribeChannelEventsAsync(ApiCallback<StreamResultOfLnrpcChannelEventUpdate> _callback) throws ApiException
      SubscribeChannelEvents creates a uni-directional stream from the server to the client in which any updates relevant to the state of the channels are sent over. Events include new active channels, inactive channels, and closed channels. (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • subscribeChannelGraphCall

      public okhttp3.Call subscribeChannelGraphCall(ApiCallback _callback) throws ApiException
      Build call for subscribeChannelGraph
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • subscribeChannelGraph

      public StreamResultOfLnrpcGraphTopologyUpdate subscribeChannelGraph() throws ApiException
      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.
      Returns:
      StreamResultOfLnrpcGraphTopologyUpdate
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • subscribeChannelGraphWithHttpInfo

      public ApiResponse<StreamResultOfLnrpcGraphTopologyUpdate> subscribeChannelGraphWithHttpInfo() throws ApiException
      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.
      Returns:
      ApiResponse<StreamResultOfLnrpcGraphTopologyUpdate>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • subscribeChannelGraphAsync

      public okhttp3.Call subscribeChannelGraphAsync(ApiCallback<StreamResultOfLnrpcGraphTopologyUpdate> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • subscribeCustomMessagesCall

      public okhttp3.Call subscribeCustomMessagesCall(ApiCallback _callback) throws ApiException
      Build call for subscribeCustomMessages
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • subscribeCustomMessages

      public StreamResultOfLnrpcCustomMessage subscribeCustomMessages() throws ApiException
      lncli: `subscribecustom` SubscribeCustomMessages subscribes to a stream of incoming custom peer messages. To include messages with type outside of the custom range (>= 32768) lnd needs to be compiled with the `dev` build tag, and the message type to override should be specified in lnd's experimental protocol configuration.
      Returns:
      StreamResultOfLnrpcCustomMessage
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • subscribeCustomMessagesWithHttpInfo

      public ApiResponse<StreamResultOfLnrpcCustomMessage> subscribeCustomMessagesWithHttpInfo() throws ApiException
      lncli: `subscribecustom` SubscribeCustomMessages subscribes to a stream of incoming custom peer messages. To include messages with type outside of the custom range (>= 32768) lnd needs to be compiled with the `dev` build tag, and the message type to override should be specified in lnd's experimental protocol configuration.
      Returns:
      ApiResponse<StreamResultOfLnrpcCustomMessage>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • subscribeCustomMessagesAsync

      public okhttp3.Call subscribeCustomMessagesAsync(ApiCallback<StreamResultOfLnrpcCustomMessage> _callback) throws ApiException
      lncli: `subscribecustom` SubscribeCustomMessages subscribes to a stream of incoming custom peer messages. (asynchronously) To include messages with type outside of the custom range (>= 32768) lnd needs to be compiled with the `dev` build tag, and the message type to override should be specified in lnd's experimental protocol configuration.
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • subscribeInvoicesCall

      public okhttp3.Call subscribeInvoicesCall(String addIndex, String settleIndex, ApiCallback _callback) throws ApiException
      Build call for subscribeInvoices
      Parameters:
      addIndex - If specified (non-zero), then we'll first start by sending out notifications for all added indexes with an add_index greater than this value. This allows callers to catch up on any events they missed while they weren't connected to the streaming RPC. (optional)
      settleIndex - If specified (non-zero), then we'll first start by sending out notifications for all settled indexes with an settle_index greater than this value. This allows callers to catch up on any events they missed while they weren't connected to the streaming RPC. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • subscribeInvoices

      public StreamResultOfLnrpcInvoice subscribeInvoices(String addIndex, String settleIndex) throws ApiException
      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.
      Parameters:
      addIndex - If specified (non-zero), then we'll first start by sending out notifications for all added indexes with an add_index greater than this value. This allows callers to catch up on any events they missed while they weren't connected to the streaming RPC. (optional)
      settleIndex - If specified (non-zero), then we'll first start by sending out notifications for all settled indexes with an settle_index greater than this value. This allows callers to catch up on any events they missed while they weren't connected to the streaming RPC. (optional)
      Returns:
      StreamResultOfLnrpcInvoice
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • subscribeInvoicesWithHttpInfo

      public ApiResponse<StreamResultOfLnrpcInvoice> subscribeInvoicesWithHttpInfo(String addIndex, String settleIndex) throws ApiException
      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.
      Parameters:
      addIndex - If specified (non-zero), then we'll first start by sending out notifications for all added indexes with an add_index greater than this value. This allows callers to catch up on any events they missed while they weren't connected to the streaming RPC. (optional)
      settleIndex - If specified (non-zero), then we'll first start by sending out notifications for all settled indexes with an settle_index greater than this value. This allows callers to catch up on any events they missed while they weren't connected to the streaming RPC. (optional)
      Returns:
      ApiResponse<StreamResultOfLnrpcInvoice>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • subscribeInvoicesAsync

      public okhttp3.Call subscribeInvoicesAsync(String addIndex, String settleIndex, ApiCallback<StreamResultOfLnrpcInvoice> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      addIndex - If specified (non-zero), then we'll first start by sending out notifications for all added indexes with an add_index greater than this value. This allows callers to catch up on any events they missed while they weren't connected to the streaming RPC. (optional)
      settleIndex - If specified (non-zero), then we'll first start by sending out notifications for all settled indexes with an settle_index greater than this value. This allows callers to catch up on any events they missed while they weren't connected to the streaming RPC. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • subscribePeerEventsCall

      public okhttp3.Call subscribePeerEventsCall(ApiCallback _callback) throws ApiException
      Build call for subscribePeerEvents
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • subscribePeerEvents

      public StreamResultOfLnrpcPeerEvent subscribePeerEvents() throws ApiException
      SubscribePeerEvents creates a uni-directional stream from the server to the client in which any events relevant to the state of peers are sent over. Events include peers going online and offline.
      Returns:
      StreamResultOfLnrpcPeerEvent
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • subscribePeerEventsWithHttpInfo

      public ApiResponse<StreamResultOfLnrpcPeerEvent> subscribePeerEventsWithHttpInfo() throws ApiException
      SubscribePeerEvents creates a uni-directional stream from the server to the client in which any events relevant to the state of peers are sent over. Events include peers going online and offline.
      Returns:
      ApiResponse<StreamResultOfLnrpcPeerEvent>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • subscribePeerEventsAsync

      public okhttp3.Call subscribePeerEventsAsync(ApiCallback<StreamResultOfLnrpcPeerEvent> _callback) throws ApiException
      SubscribePeerEvents creates a uni-directional stream from the server to the client in which any events relevant to the state of peers are sent over. Events include peers going online and offline. (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • subscribeTransactionsCall

      public okhttp3.Call subscribeTransactionsCall(Integer startHeight, Integer endHeight, String account, ApiCallback _callback) throws ApiException
      Build call for subscribeTransactions
      Parameters:
      startHeight - The height from which to list transactions, inclusive. If this value is greater than end_height, transactions will be read in reverse. (optional)
      endHeight - The height until which to list transactions, inclusive. To include unconfirmed transactions, this value should be set to -1, which will return transactions from start_height until the current chain tip and unconfirmed transactions. If no end_height is provided, the call will default to this option. (optional)
      account - An optional filter to only include transactions relevant to an account. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • subscribeTransactions

      public StreamResultOfLnrpcTransaction subscribeTransactions(Integer startHeight, Integer endHeight, String account) throws ApiException
      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.
      Parameters:
      startHeight - The height from which to list transactions, inclusive. If this value is greater than end_height, transactions will be read in reverse. (optional)
      endHeight - The height until which to list transactions, inclusive. To include unconfirmed transactions, this value should be set to -1, which will return transactions from start_height until the current chain tip and unconfirmed transactions. If no end_height is provided, the call will default to this option. (optional)
      account - An optional filter to only include transactions relevant to an account. (optional)
      Returns:
      StreamResultOfLnrpcTransaction
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • subscribeTransactionsWithHttpInfo

      public ApiResponse<StreamResultOfLnrpcTransaction> subscribeTransactionsWithHttpInfo(Integer startHeight, Integer endHeight, String account) throws ApiException
      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.
      Parameters:
      startHeight - The height from which to list transactions, inclusive. If this value is greater than end_height, transactions will be read in reverse. (optional)
      endHeight - The height until which to list transactions, inclusive. To include unconfirmed transactions, this value should be set to -1, which will return transactions from start_height until the current chain tip and unconfirmed transactions. If no end_height is provided, the call will default to this option. (optional)
      account - An optional filter to only include transactions relevant to an account. (optional)
      Returns:
      ApiResponse<StreamResultOfLnrpcTransaction>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • subscribeTransactionsAsync

      public okhttp3.Call subscribeTransactionsAsync(Integer startHeight, Integer endHeight, String account, ApiCallback<StreamResultOfLnrpcTransaction> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      startHeight - The height from which to list transactions, inclusive. If this value is greater than end_height, transactions will be read in reverse. (optional)
      endHeight - The height until which to list transactions, inclusive. To include unconfirmed transactions, this value should be set to -1, which will return transactions from start_height until the current chain tip and unconfirmed transactions. If no end_height is provided, the call will default to this option. (optional)
      account - An optional filter to only include transactions relevant to an account. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • updateChannelPolicyCall

      public okhttp3.Call updateChannelPolicyCall(LnrpcPolicyUpdateRequest body, ApiCallback _callback) throws ApiException
      Build call for updateChannelPolicy
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • updateChannelPolicy

      public LnrpcPolicyUpdateResponse updateChannelPolicy(LnrpcPolicyUpdateRequest body) throws ApiException
      lncli: `updatechanpolicy` UpdateChannelPolicy allows the caller to update the fee schedule and channel policies for all channels globally, or a particular channel.
      Parameters:
      body - (required)
      Returns:
      LnrpcPolicyUpdateResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • updateChannelPolicyWithHttpInfo

      public ApiResponse<LnrpcPolicyUpdateResponse> updateChannelPolicyWithHttpInfo(LnrpcPolicyUpdateRequest body) throws ApiException
      lncli: `updatechanpolicy` UpdateChannelPolicy allows the caller to update the fee schedule and channel policies for all channels globally, or a particular channel.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<LnrpcPolicyUpdateResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • updateChannelPolicyAsync

      public okhttp3.Call updateChannelPolicyAsync(LnrpcPolicyUpdateRequest body, ApiCallback<LnrpcPolicyUpdateResponse> _callback) throws ApiException
      lncli: `updatechanpolicy` UpdateChannelPolicy allows the caller to update the fee schedule and channel policies for all channels globally, or a particular channel. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • verifyChanBackupCall

      public okhttp3.Call verifyChanBackupCall(LnrpcChanBackupSnapshot body, ApiCallback _callback) throws ApiException
      Build call for verifyChanBackup
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • verifyChanBackup

      public Object verifyChanBackup(LnrpcChanBackupSnapshot body) throws ApiException
      VerifyChanBackup allows a caller to verify the integrity of a channel backup snapshot. This method will accept either a packed Single or a packed Multi. Specifying both will result in an error.
      Parameters:
      body - (required)
      Returns:
      Object
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • verifyChanBackupWithHttpInfo

      public ApiResponse<Object> verifyChanBackupWithHttpInfo(LnrpcChanBackupSnapshot body) throws ApiException
      VerifyChanBackup allows a caller to verify the integrity of a channel backup snapshot. This method will accept either a packed Single or a packed Multi. Specifying both will result in an error.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<Object>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • verifyChanBackupAsync

      public okhttp3.Call verifyChanBackupAsync(LnrpcChanBackupSnapshot body, ApiCallback<Object> _callback) throws ApiException
      VerifyChanBackup allows a caller to verify the integrity of a channel backup snapshot. This method will accept either a packed Single or a packed Multi. Specifying both will result in an error. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • verifyMessageCall

      public okhttp3.Call verifyMessageCall(LnrpcVerifyMessageRequest body, ApiCallback _callback) throws ApiException
      Build call for verifyMessage
      Parameters:
      body - (required)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • verifyMessage

      public LnrpcVerifyMessageResponse verifyMessage(LnrpcVerifyMessageRequest body) throws ApiException
      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.
      Parameters:
      body - (required)
      Returns:
      LnrpcVerifyMessageResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • verifyMessageWithHttpInfo

      public ApiResponse<LnrpcVerifyMessageResponse> verifyMessageWithHttpInfo(LnrpcVerifyMessageRequest body) throws ApiException
      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.
      Parameters:
      body - (required)
      Returns:
      ApiResponse<LnrpcVerifyMessageResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • verifyMessageAsync

      public okhttp3.Call verifyMessageAsync(LnrpcVerifyMessageRequest body, ApiCallback<LnrpcVerifyMessageResponse> _callback) throws ApiException
      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. (asynchronously)
      Parameters:
      body - (required)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object

    • walletBalanceCall

      public okhttp3.Call walletBalanceCall(ApiCallback _callback) throws ApiException
      Build call for walletBalance
      Parameters:
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object

    • walletBalance

      public LnrpcWalletBalanceResponse walletBalance() throws ApiException
      lncli: `walletbalance` WalletBalance returns total unspent outputs(confirmed and unconfirmed), all confirmed unspent outputs and all unconfirmed unspent outputs under control of the wallet.
      Returns:
      LnrpcWalletBalanceResponse
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • walletBalanceWithHttpInfo

      public ApiResponse<LnrpcWalletBalanceResponse> walletBalanceWithHttpInfo() throws ApiException
      lncli: `walletbalance` WalletBalance returns total unspent outputs(confirmed and unconfirmed), all confirmed unspent outputs and all unconfirmed unspent outputs under control of the wallet.
      Returns:
      ApiResponse<LnrpcWalletBalanceResponse>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

    • walletBalanceAsync

      public okhttp3.Call walletBalanceAsync(ApiCallback<LnrpcWalletBalanceResponse> _callback) throws ApiException
      lncli: `walletbalance` WalletBalance returns total unspent outputs(confirmed and unconfirmed), all confirmed unspent outputs and all unconfirmed unspent outputs under control of the wallet. (asynchronously)
      Parameters:
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object