@lightsparkdev/lightspark-sdk 0.4.10 → 1.0.0

package/src/client.ts

@@ -9,16 +9,16 @@ import type {
   KeyOrAliasType,
   Maybe,
   Query,
+  SigningKey,
 } from "@lightsparkdev/core";
 import {
-  b64encode,
   DefaultCrypto,
-  KeyOrAlias,
   LightsparkAuthException,
   LightsparkException,
   LightsparkSigningException,
   NodeKeyCache,
   Requester,
+  SigningKeyType,
   StubAuthProvider,
 } from "@lightsparkdev/core";
 import { createHash } from "crypto";
@@ -30,6 +30,7 @@ import { CreateLnurlInvoice } from "./graphql/CreateLnurlInvoice.js";
 import { CreateNodeWalletAddress } from "./graphql/CreateNodeWalletAddress.js";
 import { CreateTestModeInvoice } from "./graphql/CreateTestModeInvoice.js";
 import { CreateTestModePayment } from "./graphql/CreateTestModePayment.js";
+import { CreateUmaInvoice } from "./graphql/CreateUmaInvoice.js";
 import { DecodeInvoice } from "./graphql/DecodeInvoice.js";
 import { DeleteApiToken } from "./graphql/DeleteApiToken.js";
 import { FundNode } from "./graphql/FundNode.js";
@@ -38,12 +39,13 @@ import { LightningFeeEstimateForNode } from "./graphql/LightningFeeEstimateForNo
 import type { AccountDashboard } from "./graphql/MultiNodeDashboard.js";
 import { MultiNodeDashboard } from "./graphql/MultiNodeDashboard.js";
 import { PayInvoice } from "./graphql/PayInvoice.js";
-import { RecoverNodeSigningKey } from "./graphql/RecoverNodeSigningKey.js";
+import { PayUmaInvoice } from "./graphql/PayUmaInvoice.js";
 import { RequestWithdrawal } from "./graphql/RequestWithdrawal.js";
 import { SendPayment } from "./graphql/SendPayment.js";
 import { SingleNodeDashboard as SingleNodeDashboardQuery } from "./graphql/SingleNodeDashboard.js";
 import { TransactionsForNode } from "./graphql/TransactionsForNode.js";
 import { TransactionSubscription } from "./graphql/TransactionSubscription.js";
+import NodeKeyLoaderCache from "./NodeKeyLoaderCache.js";
 import Account from "./objects/Account.js";
 import { ApiTokenFromJson } from "./objects/ApiToken.js";
 import BitcoinNetwork from "./objects/BitcoinNetwork.js";
@@ -68,6 +70,7 @@ import { TransactionUpdateFromJson } from "./objects/TransactionUpdate.js";
 import type WithdrawalMode from "./objects/WithdrawalMode.js";
 import type WithdrawalRequest from "./objects/WithdrawalRequest.js";
 import { WithdrawalRequestFromJson } from "./objects/WithdrawalRequest.js";
+import { type SigningKeyLoaderArgs } from "./SigningKeyLoader.js";
 
 const sdkVersion = packageJson.version;
 
@@ -97,6 +100,9 @@ const sdkVersion = packageJson.version;
 class LightsparkClient {
   private requester: Requester;
   private readonly nodeKeyCache: NodeKeyCache;
+  private readonly nodeKeyLoaderCache: NodeKeyLoaderCache;
+  private readonly LIGHTSPARK_SDK_ENDPOINT =
+    process.env.LIGHTSPARK_SDK_ENDPOINT || "graphql/server/2023-09-13";
 
   /**
    * Constructs a new LightsparkClient.
@@ -110,21 +116,54 @@ class LightsparkClient {
   constructor(
     private authProvider: AuthProvider = new StubAuthProvider(),
     private readonly serverUrl: string = "api.lightspark.com",
-    private readonly cryptoImpl: CryptoInterface = DefaultCrypto
+    private readonly cryptoImpl: CryptoInterface = DefaultCrypto,
   ) {
     this.nodeKeyCache = new NodeKeyCache(this.cryptoImpl);
+    this.nodeKeyLoaderCache = new NodeKeyLoaderCache(
+      this.nodeKeyCache,
+      this.cryptoImpl,
+    );
     this.requester = new Requester(
       this.nodeKeyCache,
-      LIGHTSPARK_SDK_ENDPOINT,
+      this.LIGHTSPARK_SDK_ENDPOINT,
       `js-lightspark-sdk/${sdkVersion}`,
       authProvider,
       serverUrl,
-      this.cryptoImpl
+      this.cryptoImpl,
     );
 
     autoBind(this);
   }
 
+  /**
+   * Sets the key loader for a node. This unlocks client operations that require a private key.
+   * Passing in [NodeIdAndPasswordSigningKeyLoaderArgs] loads the RSA key for an OSK node.
+   * Passing in [MasterSeedSigningKeyLoaderArgs] loads the Secp256k1 key for a remote signing node.
+   *
+   * @param nodeId The ID of the node the key is for
+   * @param loader The loader for the key
+   */
+  public async loadNodeSigningKey(
+    nodeId: string,
+    loaderArgs: SigningKeyLoaderArgs,
+  ) {
+    this.nodeKeyLoaderCache.setLoader(nodeId, loaderArgs, this.requester);
+    const key = await this.getNodeSigningKey(nodeId);
+    return !!key;
+  }
+
+  /**
+   * Gets the signing key for a node. Must have previously called [loadNodeSigningKey].
+   *
+   * @param nodeId The ID of the node the key is for
+   * @returns The signing key for the node
+   */
+  public async getNodeSigningKey(
+    nodeId: string,
+  ): Promise<SigningKey | undefined> {
+    return await this.nodeKeyLoaderCache.getKeyWithLoader(nodeId);
+  }
+
   /**
    * Sets the auth provider for the client. This is useful for switching between auth providers if you are using
    * multiple accounts or waiting for the user to log in.
@@ -134,11 +173,11 @@ class LightsparkClient {
   public async setAuthProvider(authProvider: AuthProvider) {
     this.requester = new Requester(
       this.nodeKeyCache,
-      LIGHTSPARK_SDK_ENDPOINT,
+      this.LIGHTSPARK_SDK_ENDPOINT,
       `js-lightspark-sdk/${sdkVersion}`,
       authProvider,
       this.serverUrl,
-      this.cryptoImpl
+      this.cryptoImpl,
     );
     this.authProvider = authProvider;
   }
@@ -155,7 +194,7 @@ class LightsparkClient {
    */
   public async getCurrentAccount(): Promise<Maybe<Account>> {
     return await this.requester.executeQuery<Account>(
-      Account.getAccountQuery()
+      Account.getAccountQuery(),
     );
   }
 
@@ -172,7 +211,7 @@ class LightsparkClient {
     nodeId: string,
     numTransactions: number = 20,
     bitcoinNetwork: BitcoinNetwork = BitcoinNetwork.MAINNET,
-    afterDate: Maybe<string> = undefined
+    afterDate: Maybe<string> = undefined,
   ): Promise<Transaction[]> {
     const response = await this.requester.makeRawRequest(TransactionsForNode, {
       nodeId,
@@ -182,7 +221,7 @@ class LightsparkClient {
     });
     return (
       response.current_account?.recent_transactions.entities.map(
-        (transaction) => TransactionFromJson(transaction)
+        (transaction) => TransactionFromJson(transaction),
       ) ?? []
     );
   }
@@ -194,19 +233,19 @@ class LightsparkClient {
    * @returns A zen-observable that emits transaction updates for the given node IDs.
    */
   public listenToTransactions(
-    nodeIds: string[]
+    nodeIds: string[],
   ): Observable<TransactionUpdate | undefined> {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const response = this.requester.subscribe<{ transactions: any }>(
       TransactionSubscription,
       {
         nodeIds,
-      }
+      },
     );
     return response.map(
       (response) =>
         response?.data?.transactions &&
-        TransactionUpdateFromJson(response.data.transactions)
+        TransactionUpdateFromJson(response.data.transactions),
     );
   }
 
@@ -221,7 +260,7 @@ class LightsparkClient {
    */
   public async getAccountDashboard(
     nodeIds: string[] | undefined = undefined,
-    bitcoinNetwork: BitcoinNetwork = BitcoinNetwork.MAINNET
+    bitcoinNetwork: BitcoinNetwork = BitcoinNetwork.MAINNET,
   ): Promise<AccountDashboard> {
     const response = await this.requester.makeRawRequest(MultiNodeDashboard, {
       nodeIds: nodeIds,
@@ -240,7 +279,7 @@ class LightsparkClient {
         1. You are requesting MAINNET nodes, but you have no MAINNET nodes yet. In this case, request BitcoinNetwork.REGTEST instead.
         2. You are specifying specific node IDs, but those IDs don't exist or are not on the bitcoid network you requested.
         3. The api token or authentication mechanism you are using is not authorized to access the nodes you requested. If you're using
-           an API token, make sure it has the correct permissions for the desired network (only test tokens have access to REGTEST nodes).`
+           an API token, make sure it has the correct permissions for the desired network (only test tokens have access to REGTEST nodes).`,
       );
     }
     const account = response.current_account;
@@ -251,7 +290,6 @@ class LightsparkClient {
         return {
           color: node.color,
           displayName: node.display_name,
-          purpose: node.purpose,
           id: node.id,
           publicKey: node.public_key,
           status: node.status,
@@ -281,17 +319,17 @@ class LightsparkClient {
             requiredReserve:
               account.blockchain_balance.required_reserve &&
               CurrencyAmountFromJson(
-                account.blockchain_balance.required_reserve
+                account.blockchain_balance.required_reserve,
               ),
             availableBalance:
               account.blockchain_balance.available_balance &&
               CurrencyAmountFromJson(
-                account.blockchain_balance.available_balance
+                account.blockchain_balance.available_balance,
               ),
             unconfirmedBalance:
               account.blockchain_balance.unconfirmed_balance &&
               CurrencyAmountFromJson(
-                account.blockchain_balance.unconfirmed_balance
+                account.blockchain_balance.unconfirmed_balance,
               ),
           }
         : null,
@@ -316,7 +354,7 @@ class LightsparkClient {
   public async getSingleNodeDashboard(
     nodeId: string,
     bitcoinNetwork: BitcoinNetwork = BitcoinNetwork.MAINNET,
-    transactionsAfterDate: Maybe<string> = undefined
+    transactionsAfterDate: Maybe<string> = undefined,
   ): Promise<SingleNodeDashboard> {
     const response = await this.requester.makeRawRequest(
       SingleNodeDashboardQuery,
@@ -325,7 +363,7 @@ class LightsparkClient {
         network: bitcoinNetwork,
         numTransactions: 20,
         transactionsAfterDate,
-      }
+      },
     );
     if (!response.current_account) {
       throw new LightsparkAuthException("No current account");
@@ -338,7 +376,7 @@ class LightsparkClient {
     ) {
       throw new LightsparkException(
         "InvalidOrMissingNode",
-        "No nodes found for node dashboard"
+        "No nodes found for node dashboard",
       );
     }
     const node = account.dashboard_overview_nodes.entities[0];
@@ -354,7 +392,6 @@ class LightsparkClient {
     return {
       color: node.color,
       displayName: account.name,
-      purpose: node.purpose,
       id: node.id,
       publicKey: node.public_key,
       status: node.status,
@@ -365,16 +402,16 @@ class LightsparkClient {
       remoteBalance: currencyAmountOrUndefined(node.remote_balance),
       blockchainBalance: node.blockchain_balance && {
         availableBalance: currencyAmountOrUndefined(
-          node.blockchain_balance.available_balance
+          node.blockchain_balance.available_balance,
         ),
         confirmedBalance: currencyAmountOrUndefined(
-          node.blockchain_balance.confirmed_balance
+          node.blockchain_balance.confirmed_balance,
         ),
         unconfirmedBalance: currencyAmountOrUndefined(
-          node.blockchain_balance.unconfirmed_balance
+          node.blockchain_balance.unconfirmed_balance,
         ),
         totalBalance: currencyAmountOrUndefined(
-          node.blockchain_balance.total_balance
+          node.blockchain_balance.total_balance,
         ),
       },
       recentTransactions:
@@ -395,20 +432,29 @@ class LightsparkClient {
    * @param type The type of invoice to create. Defaults to a normal payment invoice, but you can pass InvoiceType.AMP
    *     to create an [AMP invoice](https://docs.lightning.engineering/lightning-network-tools/lnd/amp), which can be
    *     paid multiple times.
+   * @param expirySecs The number of seconds until the invoice expires. Defaults to 86400 (1 day).
    * @returns An encoded payment request for the invoice, or undefined if the invoice could not be created.
    */
   public async createInvoice(
     nodeId: string,
     amountMsats: number,
     memo: string,
-    type: InvoiceType | undefined = undefined
+    type: InvoiceType | undefined = undefined,
+    expirySecs: number | undefined = undefined,
   ): Promise<string | undefined> {
-    const response = await this.requester.makeRawRequest(CreateInvoice, {
+    const variables = {
       node_id: nodeId,
       amount_msats: amountMsats,
       memo,
       type,
-    });
+    };
+    if (expirySecs !== undefined) {
+      variables["expiry_secs"] = expirySecs;
+    }
+    const response = await this.requester.makeRawRequest(
+      CreateInvoice,
+      variables,
+    );
     return response.create_invoice?.invoice.data?.encoded_payment_request;
   }
 
@@ -424,18 +470,27 @@ class LightsparkClient {
    * @param metadata The LNURL metadata payload field in the initial payreq response. This wil be hashed and present in the
    *     h-tag (SHA256 purpose of payment) of the resulting Bolt 11 invoice. See
    *     [this spec](https://github.com/lnurl/luds/blob/luds/06.md#pay-to-static-qrnfclink) for details.
+   * @param expirySecs The number of seconds until the invoice expires. Defaults to 86400 (1 day).
    * @returns An Invoice object representing the generated invoice.
    */
   public async createLnurlInvoice(
     nodeId: string,
     amountMsats: number,
-    metadata: string
+    metadata: string,
+    expirySecs: number | undefined = undefined,
   ): Promise<Invoice | undefined> {
-    const response = await this.requester.makeRawRequest(CreateLnurlInvoice, {
+    const variables = {
       node_id: nodeId,
       amount_msats: amountMsats,
       metadata_hash: createHash("sha256").update(metadata).digest("hex"),
-    });
+    };
+    if (expirySecs !== undefined) {
+      variables["expiry_secs"] = expirySecs;
+    }
+    const response = await this.requester.makeRawRequest(
+      CreateLnurlInvoice,
+      variables,
+    );
     const invoiceJson = response.create_lnurl_invoice?.invoice;
     if (!invoiceJson) {
       return undefined;
@@ -443,6 +498,43 @@ class LightsparkClient {
     return InvoiceFromJson(invoiceJson);
   }
 
+  /**
+   * Creates a new invoice for the UMA protocol. The metadata is hashed and included in the invoice.
+   * This API generates a Lightning Invoice (follows the Bolt 11 specification) to request a payment
+   * from another Lightning Node. This should only be used for generating invoices for UMA, with `createInvoice`
+   * preferred in the general case.
+   *
+   * @param nodeId The node ID for which to create an invoice.
+   * @param amountMsats The amount of the invoice in msats. You can create a zero-amount invoice to accept any payment amount.
+   * @param metadata The LNURL metadata payload field in the initial payreq response. This wil be hashed and present in the
+   *     h-tag (SHA256 purpose of payment) of the resulting Bolt 11 invoice. See
+   *     [this spec](https://github.com/lnurl/luds/blob/luds/06.md#pay-to-static-qrnfclink) for details.
+   * @param expirySecs The number of seconds until the invoice expires. Defaults to 3600 (1 hour).
+   * @returns An Invoice object representing the generated invoice.
+   */
+  public async createUmaInvoice(
+    nodeId: string,
+    amountMsats: number,
+    metadata: string,
+    expirySecs: number | undefined = undefined,
+  ): Promise<Invoice | undefined> {
+    const variables = {
+      node_id: nodeId,
+      amount_msats: amountMsats,
+      metadata_hash: createHash("sha256").update(metadata).digest("hex"),
+      expiry_secs: expirySecs !== undefined ? expirySecs : 3600,
+    };
+    const response = await this.requester.makeRawRequest(
+      CreateUmaInvoice,
+      variables,
+    );
+    const invoiceJson = response.create_uma_invoice?.invoice;
+    if (!invoiceJson) {
+      return undefined;
+    }
+    return InvoiceFromJson(invoiceJson);
+  }
+
   /**
    * Decodes an encoded lightning invoice string.
    *
@@ -463,13 +555,13 @@ class LightsparkClient {
    * @returns A fee estimate for the given bitcoin network including a minimum fee rate, and a max-speed fee rate.
    */
   public async getBitcoinFeeEstimate(
-    bitcoinNetwork: BitcoinNetwork = BitcoinNetwork.MAINNET
+    bitcoinNetwork: BitcoinNetwork = BitcoinNetwork.MAINNET,
   ): Promise<FeeEstimate> {
     const response = await this.requester.makeRawRequest(
       BitcoinFeeEstimateQuery,
       {
         bitcoin_network: bitcoinNetwork,
-      }
+      },
     );
     return FeeEstimateFromJson(response.bitcoin_fee_estimate);
   }
@@ -486,7 +578,7 @@ class LightsparkClient {
   public async getLightningFeeEstimateForInvoice(
     nodeId: string,
     encodedPaymentRequest: string,
-    amountMsats: number | undefined = undefined
+    amountMsats: number | undefined = undefined,
   ): Promise<CurrencyAmount> {
     const response = await this.requester.makeRawRequest(
       LightningFeeEstimateForInvoice,
@@ -494,11 +586,11 @@ class LightsparkClient {
         node_id: nodeId,
         encoded_payment_request: encodedPaymentRequest,
         amount_msats: amountMsats,
-      }
+      },
     );
     return CurrencyAmountFromJson(
       response.lightning_fee_estimate_for_invoice
-        .lightning_fee_estimate_output_fee_estimate
+        .lightning_fee_estimate_output_fee_estimate,
     );
   }
 
@@ -513,7 +605,7 @@ class LightsparkClient {
   public async getLightningFeeEstimateForNode(
     nodeId: string,
     destinationNodePublicKey: string,
-    amountMsats: number
+    amountMsats: number,
   ): Promise<CurrencyAmount> {
     const response = await this.requester.makeRawRequest(
       LightningFeeEstimateForNode,
@@ -521,69 +613,12 @@ class LightsparkClient {
         node_id: nodeId,
         destination_node_public_key: destinationNodePublicKey,
         amount_msats: amountMsats,
-      }
+      },
     );
     return CurrencyAmountFromJson(
       response.lightning_fee_estimate_for_node
-        .lightning_fee_estimate_output_fee_estimate
-    );
-  }
-
-  /**
-   * Unlock the given node for sensitive operations like sending payments.
-   *
-   * @param nodeId The ID of the node to unlock.
-   * @param password The node password assigned at node creation.
-   * @returns True if the node was unlocked successfully, false otherwise.
-   */
-  public async unlockNode(nodeId: string, password: string): Promise<boolean> {
-    const encryptedKey = await this.recoverNodeSigningKey(nodeId);
-    if (!encryptedKey) {
-      console.warn("No encrypted key found for node " + nodeId);
-      return false;
-    }
-
-    const signingPrivateKey =
-      await this.cryptoImpl.decryptSecretWithNodePassword(
-        encryptedKey.cipher,
-        encryptedKey.encrypted_value,
-        password
-      );
-
-    if (!signingPrivateKey) {
-      throw new LightsparkSigningException(
-        "Unable to decrypt signing key with provided password. Please try again."
-      );
-    }
-
-    let signingPrivateKeyPEM = "";
-    if (new Uint8Array(signingPrivateKey)[0] === 48) {
-      // Support DER format - https://github.com/lightsparkdev/webdev/pull/1982
-      signingPrivateKeyPEM = b64encode(signingPrivateKey);
-    } else {
-      const dec = new TextDecoder();
-      signingPrivateKeyPEM = dec.decode(signingPrivateKey);
-    }
-
-    await this.nodeKeyCache.loadKey(
-      nodeId,
-      KeyOrAlias.key(signingPrivateKeyPEM)
+        .lightning_fee_estimate_output_fee_estimate,
     );
-    return true;
-  }
-
-  private async recoverNodeSigningKey(
-    nodeId: string
-  ): Promise<Maybe<{ encrypted_value: string; cipher: string }>> {
-    const response = await this.requester.makeRawRequest(
-      RecoverNodeSigningKey,
-      { nodeId }
-    );
-    const nodeEntity = response.entity;
-    if (nodeEntity?.__typename === "LightsparkNode") {
-      return nodeEntity.encrypted_signing_private_key;
-    }
-    return null;
   }
 
   /**
@@ -594,9 +629,13 @@ class LightsparkClient {
    */
   public async loadNodeKey(
     nodeId: string,
-    signingPrivateKeyOrAlias: KeyOrAliasType
+    signingPrivateKeyOrAlias: KeyOrAliasType,
   ) {
-    await this.nodeKeyCache.loadKey(nodeId, signingPrivateKeyOrAlias);
+    await this.nodeKeyCache.loadKey(
+      nodeId,
+      signingPrivateKeyOrAlias,
+      SigningKeyType.RSASigningKey,
+    );
   }
 
   /**
@@ -620,7 +659,7 @@ class LightsparkClient {
     encodedInvoice: string,
     maximumFeesMsats: number,
     timeoutSecs: number = 60,
-    amountMsats: number | undefined = undefined
+    amountMsats: number | undefined = undefined,
   ): Promise<OutgoingPayment | undefined> {
     if (!this.nodeKeyCache.hasKey(payerNodeId)) {
       throw new LightsparkSigningException("Paying node is not unlocked");
@@ -637,12 +676,13 @@ class LightsparkClient {
     const response = await this.requester.makeRawRequest(
       PayInvoice,
       variables,
-      payerNodeId
+      payerNodeId,
     );
     if (response.pay_invoice?.payment.outgoing_payment_failure_message) {
       throw new LightsparkException(
         "PaymentError",
-        response.pay_invoice?.payment.outgoing_payment_failure_message.rich_text_text
+        response.pay_invoice?.payment.outgoing_payment_failure_message
+          .rich_text_text,
       );
     }
     return (
@@ -651,6 +691,58 @@ class LightsparkClient {
     );
   }
 
+  /**
+   * sends an UMA payment to a node on the Lightning Network, based on the invoice
+   * (as defined by the BOLT11 specification) that you provide.
+   * This should only be used for paying UMA invoices, with `payInvoice` preferred in the general case.
+   *
+   * @param payerNodeId The ID of the node that will pay the invoice.
+   * @param encodedInvoice The encoded invoice to pay.
+   * @param maximumFeesMsats Maximum fees (in msats) to pay for the payment. This parameter is required.
+   *     As guidance, a maximum fee of 16 basis points should make almost all transactions succeed. For example,
+   *     for a transaction between 10k sats and 100k sats, this would mean a fee limit of 16 to 160 sats.
+   * @param timeoutSecs A timeout for the payment in seconds. Defaults to 60 seconds.
+   * @param amountMsats The amount to pay in msats for a zero-amount invoice. Defaults to the full amount of the
+   *     invoice. NOTE: This parameter can only be passed for a zero-amount invoice. Otherwise, the call will fail.
+   * @returns An `OutgoingPayment` object if the payment was successful, or undefined if the payment failed.
+   */
+  public async payUmaInvoice(
+    payerNodeId: string,
+    encodedInvoice: string,
+    maximumFeesMsats: number,
+    timeoutSecs: number = 60,
+    amountMsats: number | undefined = undefined,
+  ): Promise<OutgoingPayment | undefined> {
+    if (!this.nodeKeyCache.hasKey(payerNodeId)) {
+      throw new LightsparkSigningException("Paying node is not unlocked");
+    }
+    const variables: Record<string, string | number> = {
+      node_id: payerNodeId,
+      encoded_invoice: encodedInvoice,
+      timeout_secs: timeoutSecs,
+      maximum_fees_msats: maximumFeesMsats,
+    };
+    if (amountMsats !== undefined) {
+      variables.amount_msats = amountMsats;
+    }
+    const response = await this.requester.makeRawRequest(
+      PayUmaInvoice,
+      variables,
+      payerNodeId,
+    );
+    if (response.pay_invoice?.payment.outgoing_payment_failure_message) {
+      throw new LightsparkException(
+        "PaymentError",
+        response.pay_invoice?.payment.outgoing_payment_failure_message
+          .rich_text_text,
+      );
+    }
+    return (
+      response.pay_uma_invoice &&
+      OutgoingPaymentFromJson(response.pay_invoice.payment)
+    );
+  }
+
   /**
    * Sends a payment directly to a node on the Lightning Network through the public key of the node without an invoice.
    *
@@ -668,7 +760,7 @@ class LightsparkClient {
     destinationPublicKey: string,
     timeoutSecs: number = 60,
     amountMsats: number,
-    maximumFeesMsats: number
+    maximumFeesMsats: number,
   ): Promise<OutgoingPayment | undefined> {
     if (!this.nodeKeyCache.hasKey(payerNodeId)) {
       throw new LightsparkSigningException("Paying node is not unlocked");
@@ -682,12 +774,13 @@ class LightsparkClient {
         amount_msats: amountMsats,
         maximum_fees_msats: maximumFeesMsats,
       },
-      payerNodeId
+      payerNodeId,
     );
     if (response.send_payment?.payment.outgoing_payment_failure_message) {
       throw new LightsparkException(
         "PaymentError",
-        response.send_payment?.payment.outgoing_payment_failure_message.rich_text_text
+        response.send_payment?.payment.outgoing_payment_failure_message
+          .rich_text_text,
       );
     }
     return (
@@ -705,7 +798,7 @@ class LightsparkClient {
   public async createNodeWalletAddress(nodeId: string): Promise<string> {
     const response = await this.requester.makeRawRequest(
       CreateNodeWalletAddress,
-      { node_id: nodeId }
+      { node_id: nodeId },
     );
     return response.create_node_wallet_address.wallet_address;
   }
@@ -727,7 +820,7 @@ class LightsparkClient {
     nodeId: string,
     amountSats: number,
     bitcoinAddress: string,
-    mode: WithdrawalMode
+    mode: WithdrawalMode,
   ): Promise<WithdrawalRequest> {
     const response = await this.requester.makeRawRequest(
       RequestWithdrawal,
@@ -737,7 +830,7 @@ class LightsparkClient {
         bitcoin_address: bitcoinAddress,
         withdrawal_mode: mode,
       },
-      nodeId
+      nodeId,
     );
     return WithdrawalRequestFromJson(response.request_withdrawal.request);
   }
@@ -753,7 +846,7 @@ class LightsparkClient {
    */
   public async fundNode(
     nodeId: string,
-    amountSats: number | undefined = undefined
+    amountSats: number | undefined = undefined,
   ): Promise<CurrencyAmount> {
     const response = await this.requester.makeRawRequest(FundNode, {
       node_id: nodeId,
@@ -775,7 +868,7 @@ class LightsparkClient {
   public async createApiToken(
     name: string,
     transact: boolean = true,
-    testMode: boolean = true
+    testMode: boolean = true,
   ): Promise<CreateApiTokenOutput> {
     let permissions: Permission[];
     if (transact && testMode) {
@@ -820,7 +913,7 @@ class LightsparkClient {
     localNodeId: string,
     amountMsats: number,
     memo: string | undefined = undefined,
-    invoiceType: InvoiceType = InvoiceType.STANDARD
+    invoiceType: InvoiceType = InvoiceType.STANDARD,
   ): Promise<string | null> {
     return await this.executeRawQuery({
       queryPayload: CreateTestModeInvoice,
@@ -840,7 +933,7 @@ class LightsparkClient {
         if (!encodedPaymentRequest) {
           throw new LightsparkException(
             "CreateTestModeInvoiceError",
-            "Unable to create test mode invoice"
+            "Unable to create test mode invoice",
           );
         }
         return encodedPaymentRequest;
@@ -860,7 +953,7 @@ class LightsparkClient {
   public async createTestModePayment(
     localNodeId: string,
     encodedInvoice: string,
-    amountMsats: number | undefined = undefined
+    amountMsats: number | undefined = undefined,
   ): Promise<OutgoingPayment | null> {
     return await this.executeRawQuery({
       queryPayload: CreateTestModePayment,
@@ -875,7 +968,7 @@ class LightsparkClient {
         } | null;
       }) => {
         return OutgoingPaymentFromJson(
-          responseJson.create_test_mode_payment?.payment
+          responseJson.create_test_mode_payment?.payment,
         );
       },
     });
@@ -895,6 +988,4 @@ class LightsparkClient {
   }
 }
 
-const LIGHTSPARK_SDK_ENDPOINT = "graphql/server/2023-04-04";
-
 export default LightsparkClient;