case class LndRpcClient(instance: LndInstance, binaryOpt: Option[File] = None)(implicit system: ActorSystem) extends NativeProcessFactory with LndUtils with LndRouterClient with StartStopAsync[LndRpcClient] with BitcoinSLogger with Product with Serializable
- binaryOpt
Path to lnd executable
- Alphabetic
- By Inheritance
- LndRpcClient
- Serializable
- Product
- Equals
- StartStopAsync
- StartStop
- LndRouterClient
- LndUtils
- NativeProcessFactory
- BitcoinSLogger
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new LndRpcClient(instance: LndInstance, binaryOpt: Option[File] = None)(implicit system: ActorSystem)
- binaryOpt
Path to lnd executable
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- implicit def LndTransactionToTxDetails(details: Transaction): TxDetails
- Definition Classes
- LndUtils
- def abandonChannel(request: AbandonChannelRequest): Future[Unit]
- def abandonChannel(outPoint: TransactionOutPoint, pendingFundingShimOnly: Boolean): Future[Unit]
- def addInvoice(invoice: Invoice): Future[AddInvoiceResult]
- def addInvoice(descriptionHash: Sha256Digest, value: MilliSatoshis, expiry: Long): Future[AddInvoiceResult]
- def addInvoice(memo: String, value: MilliSatoshis, expiry: Long): Future[AddInvoiceResult]
- def addInvoice(descriptionHash: Sha256Digest, value: Satoshis, expiry: Long): Future[AddInvoiceResult]
- def addInvoice(memo: String, value: Satoshis, expiry: Long): Future[AddInvoiceResult]
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def attemptToPayRoutes(invoice: LnInvoice, routes: Vector[Route]): Future[Option[HTLCAttempt]]
- Definition Classes
- LndRouterClient
- val binaryOpt: Option[File]
- implicit def byteStringToByteVec(byteString: ByteString): ByteVector
- Definition Classes
- LndUtils
- implicit def byteStringVecToByteVecs(byteStrings: Vector[ByteString]): Vector[ByteVector]
- Definition Classes
- LndUtils
- implicit def byteVecToByteString(byteVector: ByteVector): ByteString
- Definition Classes
- LndUtils
- def cancelInvoice(hash: Sha256Digest): Future[Unit]
- def cancelInvoice(invoice: LnInvoice): Future[Unit]
- lazy val chainClient: ChainNotifierClient
- def channelBalance(): Future[ChannelBalances]
- implicit def channelPointToOutpoint(channelPoint: ChannelPoint): TransactionOutPoint
- Definition Classes
- LndUtils
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def closeChannel(request: CloseChannelRequest): Future[DoubleSha256DigestBE]
- def closeChannel(outPoint: TransactionOutPoint): Future[DoubleSha256DigestBE]
- def closeChannel(outPoint: TransactionOutPoint, force: Boolean, feeRate: SatoshisPerVirtualByte): Future[DoubleSha256DigestBE]
- def cmd: Vector[String]
The command to start the daemon on the underlying OS
The command to start the daemon on the underlying OS
- Definition Classes
- LndRpcClient → NativeProcessFactory
- def computeInputScript(request: SignReq): Future[Vector[(ScriptSignature, ScriptWitness)]]
- def computeInputScript(tx: Transaction, signDescriptors: Vector[SignDescriptor]): Future[Vector[(ScriptSignature, ScriptWitness)]]
- def computeInputScript(tx: Transaction, inputIdx: Int, output: TransactionOutput): Future[(ScriptSignature, ScriptWitness)]
- def computeInputScript(tx: Transaction, inputIdx: Int, output: TransactionOutput, signMethod: SignMethod): Future[(ScriptSignature, ScriptWitness)]
- def computeInputScript(tx: Transaction, inputIdx: Int, hashType: HashType, output: TransactionOutput, signMethod: SignMethod, prevOuts: Vector[TransactionOutput]): Future[(ScriptSignature, ScriptWitness)]
- def connectPeer(request: ConnectPeerRequest): Future[Unit]
- def connectPeer(nodeId: NodeId, addr: InetSocketAddress, permanent: Boolean): Future[Unit]
- def connectPeer(nodeId: NodeId, addr: InetSocketAddress): Future[Unit]
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- implicit val executionContext: ExecutionContext
- Definition Classes
- LndRpcClient → NativeProcessFactory
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def finalizePSBT(request: FinalizePsbtRequest): Future[PSBT]
- def finalizePSBT(psbt: PSBT): Future[PSBT]
- def findChannel(chanId: ShortChannelId): Future[Option[Channel]]
- def findChannel(channelPoint: TransactionOutPoint): Future[Option[Channel]]
- def fundPSBT(request: FundPsbtRequest): Future[PSBT]
- def fundPSBT(psbt: PSBT, feeRate: SatoshisPerVirtualByte): Future[PSBT]
- def fundPSBT(psbt: PSBT, feeRate: SatoshisPerVirtualByte, spendUnconfirmed: Boolean): Future[PSBT]
- def fundPSBT(psbt: PSBT, feeRate: SatoshisPerVirtualByte, account: String, spendUnconfirmed: Boolean): Future[PSBT]
- def fundPSBT(inputs: Vector[TransactionOutPoint], outputs: Map[BitcoinAddress, CurrencyUnit], feeRate: SatoshisPerVirtualByte, account: String, spendUnconfirmed: Boolean): Future[PSBT]
- def fundPSBT(inputs: Vector[TransactionOutPoint], outputs: Map[BitcoinAddress, CurrencyUnit], feeRate: SatoshisPerVirtualByte, spendUnconfirmed: Boolean): Future[PSBT]
- def genSeed(): Future[GenSeedResponse]
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def getInfo: Future[GetInfoResponse]
- def getNewAddress(addressType: AddressType): Future[BitcoinAddress]
- def getNewAddress: Future[BitcoinAddress]
- def getTransaction(txId: DoubleSha256DigestBE): Future[Option[TxDetails]]
- def getTransactions(request: GetTransactionsRequest): Future[Vector[TxDetails]]
- def getTransactions(startHeight: Int, endHeight: Int): Future[Vector[TxDetails]]
- def getTransactions(startHeight: Int): Future[Vector[TxDetails]]
- def getTransactions(): Future[Vector[TxDetails]]
- def getVersion(): Future[Version]
- def initWallet(password: String): Future[ByteString]
- val instance: LndInstance
- lazy val invoices: InvoicesClient
- def isAlive(): Boolean
- Definition Classes
- NativeProcessFactory
- def isConnected(nodeId: NodeId): Future[Boolean]
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def isStarted: Future[Boolean]
Boolean check to verify the state of the client
Boolean check to verify the state of the client
- returns
Future Boolean representing if client has started
- def isStopped: Future[Boolean]
Checks to see if the client stopped successfully
- def leaseOutput(request: LeaseOutputRequest): Future[UInt64]
LeaseOutput locks an output to the given ID, preventing it from being available for any future coin selection attempts.
LeaseOutput locks an output to the given ID, preventing it from being available for any future coin selection attempts. The absolute time of the lock's expiration is returned. The expiration of the lock can be extended by successive invocations of this RPC.
- request
LeaseOutputRequest
- returns
Unix timestamp for when the lease expires
- def leaseOutput(outpoint: TransactionOutPoint, leaseSeconds: Long): Future[UInt64]
- def listChannels(request: ListChannelsRequest = ListChannelsRequest()): Future[Vector[Channel]]
- def listLeases(request: ListLeasesRequest): Future[Vector[UTXOLease]]
- def listLeases(): Future[Vector[UTXOLease]]
- def listPeers(): Future[Vector[Peer]]
- def listPendingChannels(): Future[PendingChannelsResponse]
- def listUnspent(request: ListUnspentRequest): Future[Vector[UTXOResult]]
- def listUnspent: Future[Vector[UTXOResult]]
- lazy val lnd: LightningClient
- implicit def lndOutputDetailToOutputDetails(detail: OutputDetail): OutputDetails
- Definition Classes
- LndUtils
- def logger: Logger
- Definition Classes
- BitcoinSLogger
- def lookupInvoice(req: LookupInvoiceMsg): Future[Invoice]
- def lookupInvoice(rHash: PaymentHashTag): Future[Invoice]
- def monitorInvoice(rHash: PaymentHashTag, interval: FiniteDuration = 1.second, maxAttempts: Int = 60): Future[Invoice]
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def nodeId: Future[NodeId]
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def openChannel(request: OpenChannelRequest): Future[Option[TransactionOutPoint]]
- def openChannel(nodeId: NodeId, fundingAmount: CurrencyUnit, pushAmt: CurrencyUnit, satPerVByte: SatoshisPerVirtualByte, privateChannel: Boolean): Future[Option[TransactionOutPoint]]
- def openChannel(nodeId: NodeId, fundingAmount: CurrencyUnit, satPerVByte: SatoshisPerVirtualByte, privateChannel: Boolean): Future[Option[TransactionOutPoint]]
- implicit def outPointToChannelPoint(outPoint: TransactionOutPoint): ChannelPoint
- Definition Classes
- LndUtils
- implicit def outpointToTxOutPoint(op: OutPoint): TransactionOutPoint
- Definition Classes
- LndUtils
- implicit def outpointVecToTxOutPointVec(ops: Vector[OutPoint]): Vector[TransactionOutPoint]
- Definition Classes
- LndUtils
- implicit def outputToTxOut(output: TransactionOutput): TxOut
- Definition Classes
- LndUtils
- implicit def outputVecToTxOuts(outputs: Vector[TransactionOutput]): Vector[TxOut]
- Definition Classes
- LndUtils
- lazy val peersClient: PeersClient
- def probe(amount: Satoshis, node: NodeId, routeHints: Vector[LnRoute]): Future[Vector[Route]]
- Definition Classes
- LndRouterClient
- def probe(invoice: LnInvoice): Future[Vector[Route]]
- Definition Classes
- LndRouterClient
- def probeAndPay(invoice: LnInvoice): Future[Option[HTLCAttempt]]
- Definition Classes
- LndRouterClient
- def productElementNames: Iterator[String]
- Definition Classes
- Product
- def publishTransaction(tx: Transaction): Future[Option[String]]
Broadcasts the given transaction
Broadcasts the given transaction
- returns
None if no error, otherwise the error string
- def queryRoutes(request: QueryRoutesRequest): Future[QueryRoutesResponse]
- Definition Classes
- LndRouterClient
- def queryRoutes(amount: CurrencyUnit, node: NodeId, routeHints: Vector[LnRoute]): Future[QueryRoutesResponse]
- Definition Classes
- LndRouterClient
- def registerConfirmationsNotification(request: ConfRequest): Source[ConfEvent, NotUsed]
- def releaseOutput(request: ReleaseOutputRequest): Future[Unit]
- def releaseOutput(outpoint: TransactionOutPoint): Future[Unit]
- lazy val router: RouterClient
- def sendCustomMessage(request: SendCustomMessageRequest): Future[Unit]
- def sendCustomMessage(peer: NodeId, tpe: BigSizeUInt, data: ByteVector): Future[Unit]
- def sendCustomMessage(peer: NodeId, tlv: TLV): Future[Unit]
- def sendCustomMessage(peer: NodeId, lnMessage: LnMessage[TLV]): Future[Unit]
- def sendOutputs(request: SendOutputsRequest): Future[Transaction]
- def sendOutputs(outputs: Vector[TransactionOutput], feeRate: SatoshisPerKW, spendUnconfirmed: Boolean): Future[Transaction]
- def sendOutputs(outputs: Vector[TransactionOutput], feeRate: SatoshisPerVirtualByte, spendUnconfirmed: Boolean): Future[Transaction]
- def sendPayment(request: SendPaymentRequest): Future[Payment]
- def sendPayment(nodeId: NodeId, amount: CurrencyUnit, timeout: FiniteDuration): Future[Payment]
- def sendPayment(invoice: LnInvoice, feeLimit: Satoshis, timeout: FiniteDuration): Future[Payment]
- def sendPayment(invoice: LnInvoice, timeout: FiniteDuration): Future[Payment]
- def sendToRoute(paymentHash: Sha256Digest, route: Route, secretOpt: Option[PaymentSecret]): Future[HTLCAttempt]
- Definition Classes
- LndRouterClient
- def sendToRoute(invoice: LnInvoice, route: Route): Future[HTLCAttempt]
- Definition Classes
- LndRouterClient
- def sendToRoute(request: SendToRouteRequest): Future[HTLCAttempt]
- Definition Classes
- LndRouterClient
- def sendToRoute(hash: Sha256Digest, route: Route): Future[HTLCAttempt]
- Definition Classes
- LndRouterClient
- def signPSBT(request: SignPsbtRequest): Future[PSBT]
- def signPSBT(psbt: PSBT): Future[PSBT]
- lazy val signer: SignerClient
- def start(): Future[LndRpcClient]
Starts lnd on the local system.
Starts lnd on the local system.
- Definition Classes
- LndRpcClient → StartStop
- def startBinary(): Future[Unit]
Starts the binary by spinning up a new process
Starts the binary by spinning up a new process
- Definition Classes
- NativeProcessFactory
- lazy val stateClient: StateClient
- def stop(): Future[LndRpcClient]
Returns a Future LndRpcClient if able to shut down Lnd instance, inherits from the StartStop trait
Returns a Future LndRpcClient if able to shut down Lnd instance, inherits from the StartStop trait
- returns
A future LndRpcClient that is stopped
- Definition Classes
- LndRpcClient → StartStop
- def stopBinary(): Future[Unit]
Stops the binary by destroying the underlying operating system process
Stops the binary by destroying the underlying operating system process
If the client is a remote client (not started on the host operating system) this method is a no-op
- Definition Classes
- NativeProcessFactory
- def subscribeChannelBackups(): Source[ChanBackupSnapshot, NotUsed]
- def subscribeChannelEvents(): Source[ChannelEventUpdate, NotUsed]
- def subscribeChannelGraph(): Source[GraphTopologyUpdate, NotUsed]
- def subscribeCustomMessages(): Source[(NodeId, TLV), NotUsed]
- def subscribeInvoices(): Source[Invoice, NotUsed]
- def subscribePeerEvents(): Source[PeerEvent, NotUsed]
- def subscribeTransactions(): Source[TxDetails, NotUsed]
- def subscribeTxConfirmation(txId: DoubleSha256Digest, script: ScriptPubKey, requiredConfs: Int, heightHint: Int): Future[ConfDetails]
- def subscribeTxConfirmation(script: ScriptPubKey, requiredConfs: Int, heightHint: Int): Future[ConfDetails]
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- implicit val system: ActorSystem
- implicit def txOutToTxOutput(txOut: TxOut): TransactionOutput
- Definition Classes
- LndUtils
- implicit def txOutpointToOutpoint(outpoint: TransactionOutPoint): OutPoint
- Definition Classes
- LndUtils
- implicit def txOutpointToOutpointVec(ops: Vector[TransactionOutPoint]): Vector[OutPoint]
- Definition Classes
- LndUtils
- implicit val uint32Mapper: TypeMapper[Int, UInt32]
- Definition Classes
- LndUtils
- implicit val uint64Mapper: TypeMapper[Long, UInt64]
- Definition Classes
- LndUtils
- def unlockWallet(password: String): Future[Unit]
- lazy val unlocker: WalletUnlockerClient
- lazy val versionerClient: VersionerClient
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- lazy val wallet: WalletKitClient
- def walletBalance(): Future[WalletBalances]