Ejemplo n.º 1
0
    async def resolve_invoice_subscription(self,
                                           info,
                                           add_index=None,
                                           settle_index=None):
        try:
            if not info.context["user"].is_authenticated:
                yield Unauthenticated()
        except AttributeError as exc:
            print(exc)
            yield ServerError(
                "A server internal error (AttributeError) has occurred. :-(")

        res = LNDWallet.objects.filter(owner=info.context["user"])

        if not res:
            yield WalletInstanceNotFound()

        cfg = build_lnd_wallet_config(res.first().pk)

        channel_data = build_grpc_channel_manual(
            rpc_server="127.0.0.1",
            rpc_port=cfg.rpc_listen_port_ipv4,
            cert_path=cfg.tls_cert_path,
            macaroon_path=cfg.admin_macaroon_path,
            is_async=True)

        if channel_data.error is not None:
            yield ServerError(error_message=channel_data.error)

        try:
            stub = lnrpc.LightningStub(channel_data.channel)
            request = ln.InvoiceSubscription(
                add_index=add_index,
                settle_index=settle_index,
            )
        except Exception as exc:
            print(exc)
            yield ServerError(error_message=exc)

        try:
            async for response in stub.SubscribeInvoices(
                    request, metadata=[('macaroon', channel_data.macaroon)]):
                if not info.context["user"].is_authenticated:
                    yield Unauthenticated()
                else:
                    json_data = json.loads(MessageToJson(response))
                    invoice = InvoiceSubSuccess(LnInvoice(json_data))
                    yield invoice
        except Exception as exc:
            print(exc)
            yield ServerError(error_message=exc)
Ejemplo n.º 2
0
    def mutate(self,
               info,
               wallet_password: str,
               cipher_seed_mnemonic: [] = None,
               aezeed_passphrase: str = None,
               recovery_window: int = None):
        """https://api.lightning.community/?python#initwallet"""

        if not info.context.user.is_authenticated:
            return Unauthenticated()

        if len(wallet_password) < 8:
            return InitWalletPasswordToShortError()

        res: QuerySet = LNDWallet.objects.filter(owner=info.context.user)

        if not res:
            return InitWalletInstanceNotFound()

        wallet: LNDWallet = res.first()
        if wallet.initialized:
            return InitWalletIsInitialized()

        res = init_wallet_mutation(wallet, wallet_password,
                                   cipher_seed_mnemonic, aezeed_passphrase,
                                   recovery_window)

        if isinstance(res, InitWalletSuccess):
            wallet.initialized = True
            wallet.save()

        return res
Ejemplo n.º 3
0
    def resolve_ln_list_payments(self, info, index_offset, num_max_payments,
                                 reverse):
        """https://api.lightning.community/?python#listpayments
        
        LND does not have paging in this call yet. Every gRPC
        call will always return the complete payments dataset.
        The paging functionality is implemented on top of the
        full dataset we get from the LND daemon.
        """

        if not info.context.user.is_authenticated:
            return Unauthenticated()

        res = LNDWallet.objects.filter(owner=info.context.user)

        if not res:
            return WalletInstanceNotFound()

        cfg = build_lnd_wallet_config(res.first().pk)

        channel_data = build_grpc_channel_manual(
            rpc_server="127.0.0.1",
            rpc_port=cfg.rpc_listen_port_ipv4,
            cert_path=cfg.tls_cert_path,
            macaroon_path=cfg.admin_macaroon_path)
        if channel_data.error is not None:
            return channel_data.error

        stub = lnrpc.LightningStub(channel_data.channel)
        request = ln.ListPaymentsRequest()

        try:
            response = stub.ListPayments(request,
                                         metadata=[('macaroon',
                                                    channel_data.macaroon)])
        except grpc.RpcError as exc:
            # pylint: disable=E1101
            print(exc)
            return ServerError.generic_rpc_error(exc.code(), exc.details())

        json_data = json.loads(
            MessageToJson(
                response,
                preserving_proto_field_name=True,
                including_default_value_fields=True,
            ))

        if reverse:
            # reverse the list
            rev = json_data["payments"][::-1]
            payments = rev[index_offset:index_offset + num_max_payments]
        else:
            payments = json_data["payments"][index_offset:index_offset +
                                             num_max_payments]

        return ListPaymentsSuccess(index_offset,
                                   index_offset + num_max_payments, payments)
Ejemplo n.º 4
0
    def resolve_ln_get_info(self, info, **kwargs):
        if not info.context.user.is_authenticated:
            return Unauthenticated()

        res = LNDWallet.objects.filter(owner=info.context.user)

        if not res:
            return WalletInstanceNotFound()

        return get_info_query(res.first())
Ejemplo n.º 5
0
    def resolve_ln_list_peers(self, info, **kwargs):
        """https://api.lightning.community/#listpeers"""
        if not info.context.user.is_authenticated:
            return Unauthenticated()

        res = LNDWallet.objects.filter(owner=info.context.user)

        if not res:
            return WalletInstanceNotFound()

        return list_peers_query(info, res.first())
Ejemplo n.º 6
0
    def mutate(self, info, pubkey: str, host: str, perm: bool):
        """https://api.lightning.community/?python#connectpeer"""

        if not info.context.user.is_authenticated:
            return Unauthenticated()

        res: QuerySet = LNDWallet.objects.filter(owner=info.context.user)

        if not res:
            return WalletInstanceNotFound()

        wallet: LNDWallet = res.first()

        cfg: LNDWalletConfig = build_lnd_wallet_config(wallet.pk)

        channel_data = build_grpc_channel_manual(
            rpc_server="127.0.0.1",
            rpc_port=cfg.rpc_listen_port_ipv4,
            cert_path=cfg.tls_cert_path,
            macaroon_path=cfg.admin_macaroon_path,
        )

        if channel_data.error is not None:
            return channel_data.error

        stub = lnrpc.LightningStub(channel_data.channel)
        request = ln.ConnectPeerRequest(addr={
            "pubkey": pubkey,
            "host": host
        },
                                        perm=perm)
        try:
            response = stub.ConnectPeer(request,
                                        metadata=[('macaroon',
                                                   channel_data.macaroon)])
        except grpc.RpcError as exc:
            # pylint: disable=E1101
            print(exc)
            if "dial tcp {}: connect: connection refused".format(
                    host) in exc.details():
                return ConnectPeerError(
                    error_message="Peer refused to connect",
                    pubkey=pubkey,
                    host=host)
            if "already connected to peer: {}".format(host) in exc.details():
                return ConnectPeerError(
                    error_message="Already connected to peer",
                    pubkey=pubkey,
                    host=host)

            return ServerError.generic_rpc_error(exc.code(), exc.details())

        return ConnectPeerSuccess(pubkey=pubkey)
Ejemplo n.º 7
0
    def mutate(self,
               info,
               payment_raw: LnRawPaymentInput = None,
               payment_request: str = "",
               final_cltv_delta: int = 0,
               fee_limit: LnFeeLimit = None):

        if not info.context.user.is_authenticated:
            return SendPaymentMutation(payment_result=Unauthenticated())

        res = LNDWallet.objects.filter(owner=info.context.user)

        if not res:
            return SendPaymentMutation(payment_result=WalletInstanceNotFound())

        cfg = build_lnd_wallet_config(res.first().pk)

        channel_data = build_grpc_channel_manual(
            rpc_server="127.0.0.1",
            rpc_port=cfg.rpc_listen_port_ipv4,
            cert_path=cfg.tls_cert_path,
            macaroon_path=cfg.admin_macaroon_path,
        )
        if channel_data.error is not None:
            return SendPaymentMutation(payment_result=channel_data.error)

        stub = lnrpc.LightningStub(channel_data.channel)
        request = ln.SendRequest(payment_request=payment_request)
        try:
            response = stub.SendPaymentSync(request,
                                            metadata=[('macaroon',
                                                       channel_data.macaroon)])
        except RpcError as exc:
            # pylint: disable=E1101
            print(exc)
            if exc.details().startswith("invoice expired"):
                return SendPaymentMutation(
                    payment_result=SendPaymentError(exc.details()))
            return SendPaymentMutation(
                payment_result=ServerError.generic_rpc_error(
                    exc.code(), exc.details()))

        json_data = json.loads(MessageToJson(response))

        if response.payment_error:
            err = SendPaymentError(payment_error=response.payment_error)
            return SendPaymentMutation(payment_result=err)

        res = SendPaymentSuccess(payment_preimage=response.payment_preimage,
                                 payment_route=LnRoute(
                                     json_data["payment_route"]))
        return SendPaymentMutation(payment_result=res)
Ejemplo n.º 8
0
    def mutate(
        self,
        info,
    ):
        """https://api.lightning.community/?python#stopdaemon"""

        if not info.context.user.is_authenticated:
            return Unauthenticated()

        res: QuerySet = LNDWallet.objects.filter(owner=info.context.user)

        if not res:
            return WalletInstanceNotFound()

        wallet: LNDWallet = res.first()

        cfg: LNDWalletConfig = build_lnd_wallet_config(wallet.pk)

        channel_data = build_grpc_channel_manual(
            rpc_server="127.0.0.1",
            rpc_port=cfg.rpc_listen_port_ipv4,
            cert_path=cfg.tls_cert_path,
            macaroon_path=cfg.admin_macaroon_path,
        )

        if channel_data.error is not None:
            return channel_data.error

        # stop daemon
        stub = lnrpc.LightningStub(channel_data.channel)
        request = ln.StopRequest()
        try:
            response = stub.StopDaemon(request,
                                       metadata=[('macaroon',
                                                  channel_data.macaroon)])
        except grpc.RpcError as exc:
            # pylint: disable=E1101
            print(exc)
            return ServerError.generic_rpc_error(exc.code(), exc.details())

        start = time.time()
        while True:
            if not lnd_instance_is_running(cfg):
                return StopDaemonSuccess()

            if time.time() - start >= 10:
                return StopDaemonError(
                    error_message=
                    "Unable to shutdown the process within 10 seconds")

            time.sleep(1)
    def resolve_get_ln_wallet_status(self, info, **kwargs):
        """retrieve the current state of the wallet"""

        if not info.context.user.is_authenticated:
            return Unauthenticated()

        res = LNDWallet.objects.filter(owner=info.context.user)

        # LND instance is not yet created.
        # User should call createWallet
        if not res:
            return WalletInstanceNotFound()

        # Wallet database object was created but
        # it is not yet initialized
        if not res.first().initialized:
            return GetLnWalletStatusNotInitialized()

        cfg = build_lnd_wallet_config(res.first().pk)

        channel_data = build_grpc_channel_manual(
            rpc_server="127.0.0.1",
            rpc_port=cfg.rpc_listen_port_ipv4,
            cert_path=cfg.tls_cert_path,
            macaroon_path=cfg.admin_macaroon_path)
        if channel_data.error is not None:
            return channel_data.error

        stub = lnrpc.LightningStub(channel_data.channel)
        request = ln.GetInfoRequest()

        try:
            stub.GetInfo(request,
                         metadata=[('macaroon', channel_data.macaroon)])
        except grpc.RpcError as exc:
            # pylint: disable=E1101

            # This is a wanted exception.
            # When GetInfo returns UNIMPLEMENTED the wallet is likely locked
            if exc.code() == grpc.StatusCode.UNIMPLEMENTED:
                return GetLnWalletStatusLocked()

            # Unexpected exception
            LOGGER.exception(exc)
            return ServerError.generic_rpc_error(exc.code(), exc.details())

        return GetLnWalletStatusOperational()
Ejemplo n.º 10
0
    def resolve_ln_list_invoices(self, info, pending_only, index_offset,
                                 num_max_invoices, reverse):
        """https://api.lightning.community/?python#listinvoices"""

        if not info.context.user.is_authenticated:
            return Unauthenticated()

        res = LNDWallet.objects.filter(owner=info.context.user)

        if not res:
            return WalletInstanceNotFound()

        cfg = build_lnd_wallet_config(res.first().pk)

        channel_data = build_grpc_channel_manual(
            rpc_server="127.0.0.1",
            rpc_port=cfg.rpc_listen_port_ipv4,
            cert_path=cfg.tls_cert_path,
            macaroon_path=cfg.admin_macaroon_path)
        if channel_data.error is not None:
            return channel_data.error

        stub = lnrpc.LightningStub(channel_data.channel)
        request = ln.ListInvoiceRequest(
            pending_only=pending_only,
            index_offset=index_offset,
            num_max_invoices=num_max_invoices,
            reversed=reverse,
        )

        try:
            response = stub.ListInvoices(request,
                                         metadata=[('macaroon',
                                                    channel_data.macaroon)])
        except grpc.RpcError as exc:
            # pylint: disable=E1101
            print(exc)
            return ServerError.generic_rpc_error(exc.code(), exc.details())

        json_data = json.loads(
            MessageToJson(
                response,
                preserving_proto_field_name=True,
                including_default_value_fields=True,
            ))
        return ListInvoicesSuccess(json_data)
Ejemplo n.º 11
0
    def resolve_ln_gen_seed(self,
                            info,
                            aezeed_passphrase=None,
                            seed_entropy=None):
        """https://api.lightning.community/?python#genseed"""

        if not info.context.user.is_authenticated:
            return Unauthenticated()

        res = LNDWallet.objects.filter(owner=info.context.user)

        if not res:
            return GenSeedWalletInstanceNotFound()

        # we currently only allow one wallet per user anyway,
        # so just get the first one
        return gen_seed_query(res.first(),
                              aezeed_passphrase=aezeed_passphrase,
                              seed_entropy=seed_entropy)
Ejemplo n.º 12
0
    def mutate(self, info, autopilot: bool, wallet_password: str,
               recovery_window: int):
        """Starts the LND process and unlocks the wallet if user provides the password"""

        if not info.context.user.is_authenticated:
            return Unauthenticated()

        res: QuerySet = LNDWallet.objects.filter(owner=info.context.user)

        if not res:
            return StartDaemonInstanceNotFound()

        wallet: LNDWallet = res.first()

        return start_daemon_mutation(
            wallet,
            autopilot,
            wallet_password,
        )
Ejemplo n.º 13
0
    def mutate(self, info, pubkey: str):
        """https://api.lightning.community/?python#disconnectpeer"""

        if not info.context.user.is_authenticated:
            return Unauthenticated()

        res: QuerySet = LNDWallet.objects.filter(owner=info.context.user)

        if not res:
            return WalletInstanceNotFound()

        wallet: LNDWallet = res.first()

        cfg: LNDWalletConfig = build_lnd_wallet_config(wallet.pk)

        channel_data = build_grpc_channel_manual(
            rpc_server="127.0.0.1",
            rpc_port=cfg.rpc_listen_port_ipv4,
            cert_path=cfg.tls_cert_path,
            macaroon_path=cfg.admin_macaroon_path,
        )

        if channel_data.error is not None:
            return channel_data.error

        stub = lnrpc.LightningStub(channel_data.channel)
        request = ln.DisconnectPeerRequest(pub_key=pubkey)
        try:
            stub.DisconnectPeer(request,
                                metadata=[('macaroon', channel_data.macaroon)])
        except grpc.RpcError as exc:
            # pylint: disable=E1101
            print(exc)
            if "unable to disconnect peer: peer {} is not connected".format(
                    pubkey) in exc.details():
                return DisconnectPeerError(error_message="Peer not connected",
                                           pubkey=pubkey)

            return ServerError.generic_rpc_error(exc.code(), exc.details())

        return DisconnectPeerSuccess(pubkey=pubkey)
Ejemplo n.º 14
0
    def mutate(self, info, value, memo: str = ""):
        if not info.context.user.is_authenticated:
            return AddInvoiceMutation(result=Unauthenticated())

        res = LNDWallet.objects.filter(owner=info.context.user)

        if not res:
            return AddInvoiceMutation(result=WalletInstanceNotFound())

        cfg = build_lnd_wallet_config(res.first().pk)

        channel_data = build_grpc_channel_manual(
            rpc_server="127.0.0.1",
            rpc_port=cfg.rpc_listen_port_ipv4,
            cert_path=cfg.tls_cert_path,
            macaroon_path=cfg.admin_macaroon_path,
        )
        if channel_data.error is not None:
            return AddInvoiceMutation(result=channel_data.error)

        stub = lnrpc.LightningStub(channel_data.channel)
        request = ln.Invoice(
            value=value,
            memo=memo,
            add_index=1,
        )

        try:
            response = stub.AddInvoice(request,
                                       metadata=[('macaroon',
                                                  channel_data.macaroon)])
        except RpcError as exc:
            # pylint: disable=E1101
            print(exc)
            return AddInvoiceMutation(result=ServerError.generic_rpc_error(
                exc.code(), exc.details()))

        json_data = json.loads(MessageToJson(response))
        return AddInvoiceMutation(
            result=AddInvoiceSuccess(LnAddInvoiceResponse(json_data)))
Ejemplo n.º 15
0
    async def resolve_open_channel_subscription(self,
                                                info,
                                                node_pubkey,
                                                local_funding_amount,
                                                push_sat,
                                                private,
                                                min_htlc_msat,
                                                min_confs,
                                                spend_unconfirmed,
                                                sat_per_byte=None,
                                                remote_csv_delay=None,
                                                target_conf=None):
        try:
            if not info.context["user"].is_authenticated:
                yield Unauthenticated()
        except AttributeError as exc:
            print(exc)
            yield ServerError(
                "A server internal error (AttributeError) has occurred. :-(")

        res = LNDWallet.objects.filter(owner=info.context["user"])

        if not res:
            yield WalletInstanceNotFound()

        cfg = build_lnd_wallet_config(res.first().pk)

        channel_data = build_grpc_channel_manual(
            rpc_server="127.0.0.1",
            rpc_port=cfg.rpc_listen_port_ipv4,
            cert_path=cfg.tls_cert_path,
            macaroon_path=cfg.admin_macaroon_path,
            is_async=True)

        if channel_data.error is not None:
            yield channel_data.error

        try:
            stub = lnrpc.LightningStub(channel_data.channel)

            request = ln.OpenChannelRequest(
                node_pubkey=codecs.decode(node_pubkey, 'hex'),
                local_funding_amount=local_funding_amount,
                push_sat=push_sat,
                target_conf=target_conf,
                sat_per_byte=sat_per_byte,
                private=private,
                min_htlc_msat=min_htlc_msat,
                remote_csv_delay=remote_csv_delay,
                min_confs=min_confs,
                # spend_unconfirmed=spend_unconfirmed
            )
        except Exception as exc:
            print(exc)
            yield ServerError(error_message=str(exc))
            return

        try:
            async for response in stub.OpenChannel(request,
                                                   metadata=[
                                                       ('macaroon',
                                                        channel_data.macaroon)
                                                   ]):
                if not info.context["user"].is_authenticated:
                    yield Unauthenticated()
                else:
                    json_data = json.loads(MessageToJson(response))

                    if "chan_pending" in json_data:
                        cp = json_data["chan_pending"]
                        txid = cp["txid"] if "txid" in cp else ""
                        output_index = cp[
                            "output_index"] if "output_index" in cp else 0

                        yield ChannelPendingUpdate(
                            channel_point=ChannelPoint(txid, output_index))
                    elif "confirmation" in json_data:
                        conf = json_data["confirmation"]
                        block_sha = conf[
                            "block_sha"] if "block_sha" in conf else ""
                        block_height = conf[
                            "block_height"] if "block_height" in conf else 0
                        num_confs_left = conf[
                            "num_confs_left"] if "num_confs_left" in conf else 0
                        yield ChannelConfirmationUpdate(
                            block_sha=block_sha,
                            block_height=block_height,
                            num_confs_left=num_confs_left)
                    elif "chan_open" in json_data:
                        co = json_data["chan_open"]["channel_point"]
                        txid = co[
                            "funding_txid_bytes"] if "funding_txid_bytes" in co else ""
                        output_index = cp[
                            "output_index"] if "output_index" in co else 0
                        yield ChannelOpenUpdate(
                            channel_point=ChannelPoint(txid, output_index))
        except RpcError as grpc_error:
            # pylint: disable=E1101
            print(grpc_error)
            print(grpc_error.details())
            yield OpenChannelError(grpc_error.details())
        except Exception as exc:
            print(exc)
            yield ServerError(error_message=exc)
Ejemplo n.º 16
0
    def mutate(self, info, autopilot: bool, name: str, public_alias: str):
        if not info.context.user.is_authenticated:
            return Unauthenticated()

        return create_wallet_mutation(autopilot, name, public_alias,
                                      info.context.user)
Ejemplo n.º 17
0
 def resolve_get_current_user(self, info, **kwargs):
     if not info.context.user.is_authenticated:
         return Unauthenticated()
     return GetCurrentUserSuccess(user=info.context.user)
Ejemplo n.º 18
0
    async def resolve_close_channel_subscription(self,
                                                 info,
                                                 funding_txid,
                                                 output_index,
                                                 force,
                                                 target_conf=None,
                                                 sat_per_byte=None):
        try:
            if not info.context["user"].is_authenticated:
                yield Unauthenticated()
        except AttributeError as exc:
            print(exc)
            yield ServerError(
                "A server internal error (AttributeError) has occurred. :-(")

        res = LNDWallet.objects.filter(owner=info.context["user"])

        if not res:
            yield WalletInstanceNotFound()

        cfg = build_lnd_wallet_config(res.first().pk)

        channel_data = build_grpc_channel_manual(
            rpc_server="127.0.0.1",
            rpc_port=cfg.rpc_listen_port_ipv4,
            cert_path=cfg.tls_cert_path,
            macaroon_path=cfg.admin_macaroon_path,
            is_async=True)

        if channel_data.error is not None:
            yield channel_data.error

        try:
            stub = lnrpc.LightningStub(channel_data.channel)

            request = ln.CloseChannelRequest(
                channel_point={
                    "funding_txid_str": funding_txid,
                    "output_index": output_index
                },
                force=force,
                target_conf=target_conf,
                sat_per_byte=sat_per_byte,
            )
        except Exception as exc:
            print(exc)
            yield ServerError(error_message=str(exc))

        try:
            async for response in stub.CloseChannel(
                    request, metadata=[('macaroon', channel_data.macaroon)]):
                if not info.context["user"].is_authenticated:
                    yield Unauthenticated()
                else:
                    json_data = json.loads(MessageToJson(response))

                    if "close_pending" in json_data:
                        cp = json_data["close_pending"]
                        txid = cp["txid"] if "txid" in cp else ""
                        output_index = cp[
                            "output_index"] if "output_index" in cp else 0

                        yield ChannelClosePendingUpdate(txid=txid)
                    elif "chan_close" in json_data:
                        cc = json_data["chan_close"]
                        txid = cc[
                            "closing_txid"] if "closing_txid" in cc else ""
                        success = cc["success"] if "success" in cc else False
                        yield ChannelCloseUpdate(closing_txid=txid, success=success)
                    else:
                        msg = "Unknown update from LND: {}".format(json_data)
                        print(msg)
                        yield ServerError(error_message=msg)
        except RpcError as grpc_error:
            # pylint: disable=E1101
            print(grpc_error)
            print(grpc_error.details())
            yield CloseChannelError(grpc_error.details())
        except Exception as exc:
            print(exc)
            yield ServerError(error_message=exc)