@lightsparkdev/lightspark-sdk 0.1.6

package/dist/index.js

@@ -0,0 +1,1177 @@
+import {
+  AccountToChannelsConnection_default,
+  Account_default,
+  ApiTokenFromJson,
+  BitcoinNetwork_default,
+  ChannelStatus_default,
+  Channel_default,
+  CurrencyAmountFromJson,
+  CurrencyUnit_default,
+  FRAGMENT,
+  FRAGMENT2,
+  FRAGMENT3,
+  FRAGMENT4,
+  FRAGMENT5,
+  FRAGMENT6,
+  FRAGMENT7,
+  FRAGMENT8,
+  FRAGMENT9,
+  FeeEstimateFromJson,
+  GraphNode_default,
+  HtlcAttemptFailureCode_default,
+  IncomingPaymentAttemptStatus_default,
+  IncomingPayment_default,
+  InvoiceDataFromJson,
+  InvoiceType_default,
+  LightsparkNodePurpose_default,
+  LightsparkNodeStatus_default,
+  LightsparkNode_default,
+  NodeAddressType_default,
+  Node_default,
+  OutgoingPaymentAttemptStatus_default,
+  OutgoingPaymentAttempt_default,
+  OutgoingPaymentFromJson,
+  OutgoingPayment_default,
+  PaymentFailureReason_default,
+  PaymentRequestStatus_default,
+  Permission_default,
+  RoutingTransactionFailureReason_default,
+  TransactionFromJson,
+  TransactionStatus_default,
+  TransactionType_default,
+  TransactionUpdateFromJson,
+  WebhookEventType_default,
+  WithdrawalMode_default,
+  WithdrawalRequestFromJson,
+  WithdrawalRequestStatus_default,
+  WithdrawalRequest_default,
+  getApiTokenQuery,
+  getChannelClosingTransactionQuery,
+  getChannelOpeningTransactionQuery,
+  getDepositQuery,
+  getHopQuery,
+  getIncomingPaymentAttemptQuery,
+  getInvoiceQuery,
+  getLightningTransactionQuery,
+  getOnChainTransactionQuery,
+  getPaymentRequestQuery,
+  getRoutingTransactionQuery,
+  getTransactionQuery,
+  getWithdrawalQuery
+} from "./chunk-3VRI7CHE.js";
+
+// src/auth/AccountTokenAuthProvider.ts
+import { b64encode } from "@lightsparkdev/core";
+import autoBind from "auto-bind";
+var AccountTokenAuthProvider = class {
+  constructor(apiTokenClientId, apiTokenClientSecret) {
+    this.apiTokenClientId = apiTokenClientId;
+    this.apiTokenClientSecret = apiTokenClientSecret;
+    this.utf8AuthBytes = new TextEncoder().encode(
+      `${apiTokenClientId}:${apiTokenClientSecret}`
+    );
+    autoBind(this);
+  }
+  utf8AuthBytes;
+  async addWsConnectionParams(params) {
+    return Object.assign({}, params, {
+      client_id: this.apiTokenClientId,
+      client_secret: this.apiTokenClientSecret
+    });
+  }
+  async addAuthHeaders(headers) {
+    return Object.assign({}, headers, {
+      authorization: `Basic ${b64encode(this.utf8AuthBytes)}`
+    });
+  }
+  async isAuthorized() {
+    return true;
+  }
+};
+var AccountTokenAuthProvider_default = AccountTokenAuthProvider;
+
+// src/client.ts
+import autoBind2 from "auto-bind";
+import {
+  b64encode as b64encode2,
+  decryptSecretWithNodePassword,
+  LightsparkAuthException,
+  LightsparkException,
+  LightsparkSigningException,
+  NodeKeyCache,
+  Requester,
+  StubAuthProvider
+} from "@lightsparkdev/core";
+
+// src/graphql/BitcoinFeeEstimate.ts
+var BitcoinFeeEstimate = `
+  query BitcoinFeeEstimate($bitcoin_network: BitcoinNetwork!) {
+    bitcoin_fee_estimate(network: $bitcoin_network) {
+      ...FeeEstimateFragment
+    }
+  }
+
+  ${FRAGMENT2}
+`;
+
+// src/graphql/CreateApiToken.ts
+var CreateApiToken = `
+    mutation CreateApiToken(
+        $name: String!
+        $permissions: [Permission!]!
+    ) {
+        create_api_token(input: {
+            name: $name
+            permissions: $permissions
+        }) {
+            api_token {
+                ...ApiTokenFragment
+            }
+            client_secret
+        }
+    }
+
+${FRAGMENT3}
+`;
+
+// src/graphql/CreateInvoice.ts
+var CreateInvoice = `
+  mutation CreateInvoice(
+    $node_id: ID!
+    $amount_msats: Long!
+    $memo: String
+    $type: InvoiceType = null
+    ) {
+    create_invoice(input: { node_id: $node_id, amount_msats: $amount_msats, memo: $memo, invoice_type: $type }) {
+      invoice {
+        data {
+          encoded_payment_request
+        }
+      }
+    }
+  }
+`;
+
+// src/graphql/CreateNodeWalletAddress.ts
+var CreateNodeWalletAddress = `
+  mutation CreateNodeWalletAddress(
+    $node_id: ID!
+  ) {
+    create_node_wallet_address(input: {
+        node_id: $node_id
+    }) {
+        wallet_address
+    }
+  }
+`;
+
+// src/graphql/DecodeInvoice.ts
+var DecodeInvoice = `
+  query DecodeInvoice($encoded_payment_request: String!) {
+    decoded_payment_request(encoded_payment_request: $encoded_payment_request) {
+      __typename
+      ... on InvoiceData {
+        ...InvoiceDataFragment
+      }
+    }
+  }
+
+  ${FRAGMENT4}
+`;
+
+// src/graphql/DeleteApiToken.ts
+var DeleteApiToken = `
+    mutation DeleteApiToken(
+        $api_token_id: ID!
+    ) {
+        delete_api_token(input: {
+            api_token_id: $api_token_id
+        }) {
+            __typename
+        }
+    }
+`;
+
+// src/graphql/FundNode.ts
+var FundNode = `
+    mutation FundNode(
+        $node_id: ID!,
+        $amountSats: Long
+    ) {
+        fund_node(input: { node_id: $node_id, amount_sats: $amountMsats }) {
+            amount {
+                ...CurrencyAmountFragment
+            }
+        }
+    }
+
+${FRAGMENT}
+`;
+
+// src/graphql/LightningFeeEstimateForInvoice.ts
+var LightningFeeEstimateForInvoice = `
+  query LightningFeeEstimateForInvoice(
+    $node_id: ID!
+    $encoded_payment_request: String!
+    $amount_msats: Long
+  ) {
+    lightning_fee_estimate_for_invoice(input: {
+      node_id: $node_id,
+      encoded_payment_request: $encoded_payment_request,
+      amount_msats: $amount_msats
+    }) {
+      ...LightningFeeEstimateOutputFragment
+    }
+  }
+
+  ${FRAGMENT5}
+`;
+
+// src/graphql/LightningFeeEstimateForNode.ts
+var LightningFeeEstimateForNode = `
+  query LightningFeeEstimateForNode(
+    $node_id: ID!
+    $destination_node_public_key: String!
+    $amount_msats: Long!
+  ) {
+    lightning_fee_estimate_for_node(input: {
+      node_id: $node_id,
+      destination_node_public_key: $destination_node_public_key,
+      amount_msats: $amount_msats
+    }) {
+      ...LightningFeeEstimateOutputFragment
+    }
+  }
+
+  ${FRAGMENT5}
+`;
+
+// src/graphql/MultiNodeDashboard.ts
+var MultiNodeDashboard = `
+  query MultiNodeDashboard(
+    $network: BitcoinNetwork!,
+    $nodeIds: [ID!]
+  ) {
+    current_account {
+      id
+      name
+      dashboard_overview_nodes: nodes(
+        bitcoin_networks: [$network]
+        node_ids: $nodeIds
+      ) {
+        count
+        entities {
+          color
+          display_name
+          purpose
+          id
+          addresses(first: 1) {
+            entities {
+              address
+              type
+              __typename
+            }
+            count
+            __typename
+          }
+          public_key
+          status
+          local_balance {
+            ...CurrencyAmountFragment
+          }
+          remote_balance {
+            ...CurrencyAmountFragment
+          }
+          blockchain_balance {
+            available_balance {
+              ...CurrencyAmountFragment
+            }
+            total_balance {
+              ...CurrencyAmountFragment
+            }
+            __typename
+          }
+          __typename
+        }
+        __typename
+      }
+      blockchain_balance(bitcoin_networks: [$network], node_ids: $nodeIds) {
+        l1_balance: total_balance {
+          ...CurrencyAmountFragment
+        }
+        required_reserve {
+          ...CurrencyAmountFragment
+        }
+        available_balance {
+          ...CurrencyAmountFragment
+        }
+        unconfirmed_balance {
+          ...CurrencyAmountFragment
+        }
+        __typename
+      }
+      local_balance(bitcoin_networks: [$network], node_ids: $nodeIds) {
+        ...CurrencyAmountFragment
+      }
+      remote_balance(bitcoin_networks: [$network], node_ids: $nodeIds) {
+        ...CurrencyAmountFragment
+      }
+    }
+  }
+
+  ${FRAGMENT}
+`;
+
+// src/graphql/PayInvoice.ts
+var PayInvoice = `
+  mutation PayInvoice(
+    $node_id: ID!
+    $encoded_invoice: String!
+    $timeout_secs: Int!
+    $maximum_fees_msats: Long!
+    $amount_msats: Long
+  ) {
+    pay_invoice(
+      input: {
+        node_id: $node_id
+        encoded_invoice: $encoded_invoice
+        timeout_secs: $timeout_secs
+        maximum_fees_msats: $maximum_fees_msats
+        amount_msats: $amount_msats
+      }
+    ) {
+      payment {
+        ...OutgoingPaymentFragment
+      }
+    }
+  }
+
+  ${FRAGMENT6}
+`;
+
+// src/graphql/RecoverNodeSigningKey.ts
+var RecoverNodeSigningKey = `
+  query RecoverNodeSigningKey($nodeId: ID!) {
+    entity(id: $nodeId) {
+      __typename
+      ... on LightsparkNode {
+        encrypted_signing_private_key {
+          encrypted_value
+          cipher
+        }
+      }
+    }
+  }
+`;
+
+// src/graphql/RequestWithdrawal.ts
+var RequestWithdrawal = `
+  mutation RequestWithdrawal(
+    $node_id: ID!
+    $bitcoin_address: String!
+    $amount_sats: Long!
+    $withdrawal_mode: WithdrawalMode!
+  ) {
+    request_withdrawal(input: {
+      node_id: $node_id
+      bitcoin_address: $bitcoin_address
+      amount_sats: $amount_sats
+      withdrawal_mode: $withdrawal_mode
+    }) {
+        request {
+            ...WithdrawalRequestFragment
+        }
+    }
+  }
+
+  ${FRAGMENT7}
+`;
+
+// src/graphql/SendPayment.ts
+var SendPayment = `
+  mutation SendPayment(
+    $node_id: ID!
+    $destination_public_key: String!
+    $timeout_secs: Int!
+    $amount_msats: Long!
+    $maximum_fees_msats: Long!
+  ) {
+    send_payment(
+      input: {
+        node_id: $node_id
+        destination_public_key: $destination_public_key
+        timeout_secs: $timeout_secs
+        amount_msats: $amount_msats
+        maximum_fees_msats: $maximum_fees_msats
+      }
+    ) {
+      payment {
+        ...OutgoingPaymentFragment
+      }
+    }
+  }
+
+  ${FRAGMENT6}
+`;
+
+// src/graphql/SingleNodeDashboard.ts
+var SingleNodeDashboard = `
+query SingleNodeDashboard(
+    $network: BitcoinNetwork!,
+    $nodeId: ID!,
+    $numTransactions: Int,
+    $transactionsAfterDate: DateTime,
+    $transactionTypes: [TransactionType!] = [PAYMENT, PAYMENT_REQUEST, ROUTE, L1_WITHDRAW, L1_DEPOSIT]
+    $transaction_statuses: [TransactionStatus!] = null
+) {
+    current_account {
+        id
+        name
+        dashboard_overview_nodes: nodes(
+            first: 1
+            bitcoin_networks: [$network]
+            node_ids: [$nodeId]
+        ) {
+            count
+            entities {
+                color
+                display_name
+                purpose
+                id
+                addresses(first: 1) {
+                    entities {
+                        address
+                        type
+                        __typename
+                    }
+                    count
+                    __typename
+                }
+                public_key
+                status
+                total_local_balance {
+                    ...CurrencyAmountFragment
+                }
+                local_balance {
+                    ...CurrencyAmountFragment
+                }
+                remote_balance {
+                    ...CurrencyAmountFragment
+                }
+                blockchain_balance {
+                    confirmed_balance {
+                        ...CurrencyAmountFragment
+                    }
+                    unconfirmed_balance {
+                        ...CurrencyAmountFragment
+                    }
+                    available_balance {
+                        ...CurrencyAmountFragment
+                    }
+                    total_balance {
+                        ...CurrencyAmountFragment
+                    }
+                    __typename
+                }
+                __typename
+            }
+            __typename
+        }
+        blockchain_balance(bitcoin_networks: [$network], node_ids: [$nodeId]) {
+            total_balance: total_balance {
+                ...CurrencyAmountFragment
+            }
+            required_reserve {
+                ...CurrencyAmountFragment
+            }
+            available_balance {
+                ...CurrencyAmountFragment
+            }
+            unconfirmed_balance {
+                ...CurrencyAmountFragment
+            }
+            confirmed_balance {
+                ...CurrencyAmountFragment
+            }
+            __typename
+        }
+        local_balance(bitcoin_networks: [$network], node_ids: [$nodeId]) {
+            ...CurrencyAmountFragment
+        }
+        remote_balance(bitcoin_networks: [$network], node_ids: [$nodeId]) {
+            ...CurrencyAmountFragment
+        }
+        recent_transactions: transactions(
+            first: $numTransactions
+            types: $transactionTypes
+            bitcoin_network: $network
+            lightning_node_id: $nodeId
+            statuses: $transaction_statuses
+            after_date: $transactionsAfterDate
+        ) {
+            count
+            total_amount_transacted {
+                ...CurrencyAmountFragment
+            }
+            entities {
+                ...TransactionFragment
+                __typename
+            }
+            __typename
+        }
+        __typename
+    }
+}
+
+${FRAGMENT8}
+${FRAGMENT}
+`;
+
+// src/graphql/TransactionsForNode.ts
+var TransactionsForNode = `
+query TransactionsForNode(
+    $network: BitcoinNetwork!,
+    $nodeId: ID!,
+    $numTransactions: Int,
+    $afterDate: DateTime,
+    $transactionTypes: [TransactionType!] = [PAYMENT, PAYMENT_REQUEST, ROUTE, L1_WITHDRAW, L1_DEPOSIT]
+    $transaction_statuses: [TransactionStatus!] = null
+) {
+    current_account {
+        id
+        name
+        recent_transactions: transactions(
+            first: $numTransactions
+            types: $transactionTypes
+            bitcoin_network: $network
+            lightning_node_id: $nodeId
+            statuses: $transaction_statuses
+            after_date: $afterDate
+        ) {
+            count
+            total_amount_transacted {
+                ...CurrencyAmountFragment
+            }
+            entities {
+                ...TransactionFragment
+                __typename
+            }
+            __typename
+        }
+        __typename
+    }
+}
+
+${FRAGMENT8}
+${FRAGMENT}
+`;
+
+// src/graphql/TransactionSubscription.ts
+var TransactionSubscription = `
+subscription TransactionSubscription(
+    $nodeIds: [ID!]!
+) {
+    transactions(node_ids: $nodeIds) {
+        ...TransactionUpdateFragment
+        __typename
+    }
+}
+
+${FRAGMENT9}
+`;
+
+// src/client.ts
+var LightsparkClient = class {
+  /**
+   * Constructs a new LightsparkClient.
+   *
+   * @param authProvider The auth provider to use for authentication. Defaults to a stub auth provider. For server-side
+   *     use, you should use the `AccountTokenAuthProvider`.
+   * @param serverUrl The base URL of the server to connect to. Defaults to lightspark production.
+   * @param nodeKeyCache This is used to cache node keys for the duration of the session. Defaults to a new instance of
+   *     `NodeKeyCache`. You should not need to change this.
+   */
+  constructor(authProvider = new StubAuthProvider(), serverUrl = "api.lightspark.com", nodeKeyCache = new NodeKeyCache()) {
+    this.authProvider = authProvider;
+    this.serverUrl = serverUrl;
+    this.nodeKeyCache = nodeKeyCache;
+    this.requester = new Requester(
+      this.nodeKeyCache,
+      WALLET_SDK_ENDPOINT,
+      authProvider,
+      serverUrl
+    );
+    autoBind2(this);
+  }
+  requester;
+  /**
+   * 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.
+   *
+   * @param authProvider
+   */
+  async setAuthProvider(authProvider) {
+    this.requester = new Requester(
+      this.nodeKeyCache,
+      WALLET_SDK_ENDPOINT,
+      authProvider,
+      this.serverUrl
+    );
+    this.authProvider = authProvider;
+  }
+  /**
+   * @returns Whether or not the client is authorized. This is useful for determining if the user is logged in or not.
+   */
+  async isAuthorized() {
+    return this.authProvider.isAuthorized();
+  }
+  /**
+   * @returns The current account, if one exists.
+   */
+  async getCurrentAccount() {
+    return await this.requester.executeQuery(
+      Account_default.getAccountQuery()
+    );
+  }
+  /**
+   * Retrieves the most recent transactions for a given node.
+   *
+   * @param nodeId The node ID for which to read transactions
+   * @param numTransactions The maximum number of transactions to read. Defaults to 20.
+   * @param bitcoinNetwork The bitcoin network on which to read transactions. Defaults to MAINNET.
+   * @param afterDate Filters transactions to those after the given date. Defaults to undefined (no limit).
+   * @returns An array of transactions for the given node ID.
+   */
+  async getRecentTransactions(nodeId, numTransactions = 20, bitcoinNetwork = BitcoinNetwork_default.MAINNET, afterDate = void 0) {
+    const response = await this.requester.makeRawRequest(TransactionsForNode, {
+      nodeId,
+      network: bitcoinNetwork,
+      numTransactions,
+      afterDate
+    });
+    return response.current_account?.recent_transactions.entities.map(
+      (transaction) => TransactionFromJson(transaction)
+    ) ?? [];
+  }
+  /**
+   * Starts listening for new transactions or updates to existing transactions for a list of nodes.
+   *
+   * @param nodeIds The node IDs for which to listen to transactions.
+   * @returns A zen-observable that emits transaction updates for the given node IDs.
+   */
+  listenToTransactions(nodeIds) {
+    const response = this.requester.subscribe(TransactionSubscription, {
+      nodeIds
+    });
+    return response.map(
+      (response2) => response2 && response2.data.transactions && TransactionUpdateFromJson(response2.data.transactions)
+    );
+  }
+  /**
+   * Retrieves a dashboard of basic info for the authenticated account. See `AccountDashboard` for which info is
+   * included.
+   *
+   * @param nodeIds The node IDs to include in the dashboard. Defaults to undefined (all nodes).
+   * @param bitcoinNetwork The bitcoin network to include in the dashboard. Defaults to MAINNET.
+   * @returns A basic account dashboard for the given node IDs.
+   * @throws LightsparkAuthException if the user is not logged in or a LightsparkException if no nodes are found.
+   */
+  async getAccountDashboard(nodeIds = void 0, bitcoinNetwork = BitcoinNetwork_default.MAINNET) {
+    const response = await this.requester.makeRawRequest(MultiNodeDashboard, {
+      nodeIds,
+      network: bitcoinNetwork
+    });
+    if (!response.current_account) {
+      throw new LightsparkAuthException("No current account");
+    }
+    if (!response.current_account.dashboard_overview_nodes || response.current_account.dashboard_overview_nodes.entities.length === 0) {
+      throw new LightsparkException(
+        "NO_NODES_FOUND",
+        `No nodes found for this dashboard request. This could mean one of a few things:
+        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).`
+      );
+    }
+    const account = response.current_account;
+    return {
+      id: account.id,
+      name: account.name,
+      nodes: account.dashboard_overview_nodes.entities.map((node) => {
+        return {
+          color: node.color,
+          displayName: node.display_name,
+          purpose: node.purpose,
+          id: node.id,
+          publicKey: node.public_key,
+          status: node.status,
+          addresses: {
+            count: node.addresses.count,
+            entities: node.addresses.entities.map((address) => {
+              return {
+                address: address.address,
+                type: address.type
+              };
+            })
+          },
+          localBalance: node.local_balance && CurrencyAmountFromJson(node.local_balance),
+          remoteBalance: node.remote_balance && CurrencyAmountFromJson(node.remote_balance),
+          blockchainBalance: node.blockchain_balance && CurrencyAmountFromJson(node.blockchain_balance)
+        };
+      }),
+      blockchainBalance: !!account.blockchain_balance ? {
+        l1Balance: account.blockchain_balance.l1_balance && CurrencyAmountFromJson(account.blockchain_balance.l1_balance),
+        requiredReserve: account.blockchain_balance.required_reserve && CurrencyAmountFromJson(
+          account.blockchain_balance.required_reserve
+        ),
+        availableBalance: account.blockchain_balance.available_balance && CurrencyAmountFromJson(
+          account.blockchain_balance.available_balance
+        ),
+        unconfirmedBalance: account.blockchain_balance.unconfirmed_balance && CurrencyAmountFromJson(
+          account.blockchain_balance.unconfirmed_balance
+        )
+      } : null,
+      localBalance: account.local_balance && CurrencyAmountFromJson(account.local_balance),
+      remoteBalance: account.remote_balance && CurrencyAmountFromJson(account.remote_balance)
+    };
+  }
+  /**
+   * Gets a basic dashboard for a single node, including recent transactions. See `WalletDashboard` for which info is
+   * included.
+   *
+   * @param nodeId The node ID for which to get a dashboard.
+   * @param bitcoinNetwork The bitcoin network for which to get a dashboard. Defaults to MAINNET.
+   * @param transactionsAfterDate Filters recent transactions to those after the given date.
+   *     Defaults to undefined (no limit).
+   * @returns A basic dashboard for the given node ID.
+   */
+  async getSingleNodeDashboard(nodeId, bitcoinNetwork = BitcoinNetwork_default.MAINNET, transactionsAfterDate = void 0) {
+    const response = await this.requester.makeRawRequest(SingleNodeDashboard, {
+      nodeId,
+      network: bitcoinNetwork,
+      numTransactions: 20,
+      transactionsAfterDate
+    });
+    if (!response.current_account) {
+      throw new LightsparkAuthException("No current account");
+    }
+    const account = response.current_account;
+    if (!account.dashboard_overview_nodes || !account.dashboard_overview_nodes.entities || account.dashboard_overview_nodes.entities.length === 0) {
+      throw new LightsparkException(
+        "InvalidOrMissingNode",
+        "No nodes found for node dashboard"
+      );
+    }
+    const node = account.dashboard_overview_nodes.entities[0];
+    const nodeAddresses = node.addresses.entities.map((address) => {
+      return {
+        address: address.address,
+        type: address.type
+      };
+    });
+    const currencyAmountOrUndefined = (json) => {
+      return json && CurrencyAmountFromJson(json);
+    };
+    return {
+      color: node.color,
+      displayName: account.name,
+      purpose: node.purpose,
+      id: node.id,
+      publicKey: node.public_key,
+      status: node.status,
+      addresses: nodeAddresses,
+      totalBalance: currencyAmountOrUndefined(node.total_balance),
+      totalLocalBalance: currencyAmountOrUndefined(node.total_local_balance),
+      onlineLocalBalance: currencyAmountOrUndefined(node.local_balance),
+      remoteBalance: currencyAmountOrUndefined(node.remote_balance),
+      blockchainBalance: node.blockchain_balance && {
+        availableBalance: currencyAmountOrUndefined(
+          node.blockchain_balance.available_balance
+        ),
+        confirmedBalance: currencyAmountOrUndefined(
+          node.blockchain_balance.confirmed_balance
+        ),
+        unconfirmedBalance: currencyAmountOrUndefined(
+          node.blockchain_balance.unconfirmed_balance
+        ),
+        totalBalance: currencyAmountOrUndefined(
+          node.blockchain_balance.total_balance
+        )
+      },
+      recentTransactions: account.recent_transactions?.entities.map((tx) => {
+        return TransactionFromJson(tx);
+      }) || []
+    };
+  }
+  /**
+   * Creates an invoice for the given node.
+   *
+   * @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 memo A string memo to include in the invoice as a description.
+   * @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.
+   * @returns An encoded payment request for the invoice, or undefined if the invoice could not be created.
+   */
+  async createInvoice(nodeId, amountMsats, memo, type = void 0) {
+    const response = await this.requester.makeRawRequest(CreateInvoice, {
+      node_id: nodeId,
+      amount_msats: amountMsats,
+      memo,
+      type
+    });
+    return response.create_invoice?.invoice.data?.encoded_payment_request;
+  }
+  /**
+   * Decodes an encoded lightning invoice string.
+   *
+   * @param encodedInvoice The string encoded invoice to decode.
+   * @returns Decoded invoice data.
+   */
+  async decodeInvoice(encodedInvoice) {
+    const response = await this.requester.makeRawRequest(DecodeInvoice, {
+      encoded_payment_request: encodedInvoice
+    });
+    return InvoiceDataFromJson(response.decoded_payment_request);
+  }
+  /**
+   * Gets an estimate of the fee for sending a payment over the given bitcoin network.
+   *
+   * @param bitcoinNetwork The bitcoin network for which to get a fee estimate. Defaults to MAINNET.
+   * @returns A fee estimate for the given bitcoin network including a minimum fee rate, and a max-speed fee rate.
+   */
+  async getBitcoinFeeEstimate(bitcoinNetwork = BitcoinNetwork_default.MAINNET) {
+    const response = await this.requester.makeRawRequest(
+      BitcoinFeeEstimate,
+      {
+        bitcoin_network: bitcoinNetwork
+      }
+    );
+    return FeeEstimateFromJson(response.bitcoin_fee_estimate);
+  }
+  /**
+   * Gets an estimate of the fees that will be paid for a Lightning invoice.
+   *
+   * @param nodeId The node from where you want to send the payment.
+   * @param encodedPaymentRequest The invoice you want to pay (as defined by the BOLT11 standard).
+   * @param amountMsats If the invoice does not specify a payment amount, then the amount that you wish to pay,
+   *     expressed in msats.
+   * @returns An estimate of the fees that will be paid for a Lightning invoice.
+   */
+  async getLightningFeeEstimateForInvoice(nodeId, encodedPaymentRequest, amountMsats = void 0) {
+    const response = await this.requester.makeRawRequest(
+      LightningFeeEstimateForInvoice,
+      {
+        node_id: nodeId,
+        encoded_payment_request: encodedPaymentRequest,
+        amount_msats: amountMsats
+      }
+    );
+    return CurrencyAmountFromJson(
+      response.lightning_fee_estimate_for_invoice.fee_estimate
+    );
+  }
+  /**
+   * Returns an estimate of the fees that will be paid to send a payment to another Lightning node.
+   *
+   * @param nodeId The node from where you want to send the payment.
+   * @param destinationNodePublicKey The public key of the node that you want to pay.
+   * @param amountMsats The payment amount expressed in msats.
+   * @returns An estimate of the fees that will be paid to send a payment to another Lightning node.
+   */
+  async getLightningFeeEstimateForNode(nodeId, destinationNodePublicKey, amountMsats) {
+    const response = await this.requester.makeRawRequest(
+      LightningFeeEstimateForNode,
+      {
+        node_id: nodeId,
+        destination_node_public_key: destinationNodePublicKey,
+        amount_msats: amountMsats
+      }
+    );
+    return CurrencyAmountFromJson(
+      response.lightning_fee_estimate_for_node.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.
+   */
+  async unlockNode(nodeId, password) {
+    const encryptedKey = await this.recoverNodeSigningKey(nodeId);
+    if (!encryptedKey) {
+      console.warn("No encrypted key found for node " + nodeId);
+      return false;
+    }
+    const signingPrivateKey = await 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) {
+      signingPrivateKeyPEM = b64encode2(signingPrivateKey);
+    } else {
+      const dec = new TextDecoder();
+      signingPrivateKeyPEM = dec.decode(signingPrivateKey);
+    }
+    await this.nodeKeyCache.loadKey(nodeId, signingPrivateKeyPEM);
+    return true;
+  }
+  async recoverNodeSigningKey(nodeId) {
+    const response = await this.requester.makeRawRequest(
+      RecoverNodeSigningKey,
+      { nodeId }
+    );
+    const nodeEntity = response.entity;
+    if (nodeEntity?.__typename === "LightsparkNode") {
+      return nodeEntity.encrypted_signing_private_key;
+    }
+    return null;
+  }
+  /**
+   * Directly unlocks a node with a signing private key.
+   *
+   * @param nodeId The ID of the node to unlock.
+   * @param signingPrivateKeyPEM The PEM-encoded signing private key.
+   */
+  async loadNodeKey(nodeId, signingPrivateKeyPEM) {
+    await this.nodeKeyCache.loadKey(nodeId, signingPrivateKeyPEM);
+  }
+  /**
+   * Sends a lightning payment for a given invoice.
+   *
+   * @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.
+   */
+  async payInvoice(payerNodeId, encodedInvoice, maximumFeesMsats, timeoutSecs = 60, amountMsats = void 0) {
+    if (!this.nodeKeyCache.hasKey(payerNodeId)) {
+      throw new LightsparkSigningException("Paying node is not unlocked");
+    }
+    const variables = {
+      node_id: payerNodeId,
+      encoded_invoice: encodedInvoice,
+      timeout_secs: timeoutSecs,
+      maximum_fees_msats: maximumFeesMsats
+    };
+    if (amountMsats !== void 0) {
+      variables.amount_msats = amountMsats;
+    }
+    const response = await this.requester.makeRawRequest(
+      PayInvoice,
+      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_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.
+   *
+   * @param payerNodeId The ID of the node that will send the payment.
+   * @param destinationPublicKey The public key of the destination node.
+   * @param timeoutSecs The timeout in seconds that we will try to make the payment.
+   * @param amountMsats The amount to pay in msats.
+   * @param maximumFeesMsats Maximum fees (in msats) to pay for the payment. This parameter is required.
+   *     As guidance, a maximum fee of 15 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 15 to 150 sats.
+   * @returns An `OutgoingPayment` object if the payment was successful, or undefined if the payment failed.
+   */
+  async sendPayment(payerNodeId, destinationPublicKey, timeoutSecs = 60, amountMsats, maximumFeesMsats) {
+    if (!this.nodeKeyCache.hasKey(payerNodeId)) {
+      throw new LightsparkSigningException("Paying node is not unlocked");
+    }
+    const response = await this.requester.makeRawRequest(
+      SendPayment,
+      {
+        node_id: payerNodeId,
+        destination_public_key: destinationPublicKey,
+        timeout_secs: timeoutSecs,
+        amount_msats: amountMsats,
+        maximum_fees_msats: maximumFeesMsats
+      },
+      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
+      );
+    }
+    return response.send_payment && OutgoingPaymentFromJson(response.send_payment.payment);
+  }
+  /**
+   * Creates an L1 Bitcoin wallet address for a given node which can be used to deposit or withdraw funds.
+   *
+   * @param nodeId The ID of the node to create a wallet address for.
+   * @returns A string containing the wallet address for the given node.
+   */
+  async createNodeWalletAddress(nodeId) {
+    const response = await this.requester.makeRawRequest(
+      CreateNodeWalletAddress,
+      { node_id: nodeId }
+    );
+    return response.create_node_wallet_address.wallet_address;
+  }
+  /**
+   * Withdraws funds from the account and sends it to the requested bitcoin address.
+   *
+   * Depending on the chosen mode, it will first take the funds from the wallet, and if applicable, close channels
+   * appropriately to recover enough funds and reopen channels with the remaining funds.
+   * The process is asynchronous and may take up to a few minutes. You can check the progress by polling the
+   * `WithdrawalRequest` that is created, or by subscribing to a webhook.
+   *
+   * @param nodeId The ID of the node from which to withdraw funds.
+   * @param amountSats The amount of funds to withdraw in satoshis.
+   * @param bitcoinAddress The Bitcoin address to withdraw funds to.
+   * @param mode The mode to use for the withdrawal. See `WithdrawalMode` for more information.
+   */
+  async requestWithdrawal(nodeId, amountSats, bitcoinAddress, mode) {
+    const response = await this.requester.makeRawRequest(
+      RequestWithdrawal,
+      {
+        node_id: nodeId,
+        amount_sats: amountSats,
+        bitcoin_address: bitcoinAddress,
+        withdrawal_mode: mode
+      },
+      nodeId
+    );
+    return WithdrawalRequestFromJson(response.request_withdrawal.request);
+  }
+  /**
+   * Adds funds to a Lightspark node on the REGTEST network. If the amount is not specified, 10,000,000 SATOSHI will be
+   * added. This API only functions for nodes created on the REGTEST network and will return an error when called for
+   * any non-REGTEST node.
+   *
+   * @param nodeId The ID of the node to fund. Must be a REGTEST node.
+   * @param amountSats The amount of funds to add to the node in satoshis. Defaults to 10,000,000 SATOSHI.
+   * @returns
+   */
+  async fundNode(nodeId, amountSats = void 0) {
+    const response = await this.requester.makeRawRequest(FundNode, {
+      node_id: nodeId,
+      amount_sats: amountSats
+    });
+    return CurrencyAmountFromJson(response.fund_node.amount);
+  }
+  /**
+   * Creates a new API token that can be used to authenticate requests for this account when using the Lightspark APIs
+   * and SDKs.
+   *
+   * @param name Creates a new API token that can be used to authenticate requests for this account when using the
+   *     Lightspark APIs and SDKs.
+   * @param transact Whether the token should be able to transact or only view data.
+   * @param testMode True if the token should be able to access only testnet false to access only mainnet.
+   * @returns An object containing the API token and client secret.
+   */
+  async createApiToken(name, transact = true, testMode = true) {
+    let permissions;
+    if (transact && testMode) {
+      permissions = [Permission_default.REGTEST_VIEW, Permission_default.REGTEST_TRANSACT];
+    } else if (transact && !testMode) {
+      permissions = [Permission_default.MAINNET_VIEW, Permission_default.MAINNET_TRANSACT];
+    } else if (!transact && testMode) {
+      permissions = [Permission_default.REGTEST_VIEW];
+    } else {
+      permissions = [Permission_default.MAINNET_VIEW];
+    }
+    const response = await this.requester.makeRawRequest(CreateApiToken, {
+      name,
+      permissions
+    });
+    return {
+      apiToken: ApiTokenFromJson(response.create_api_token.api_token),
+      clientSecret: response.create_api_token.client_secret
+    };
+  }
+  /**
+   * Deletes an existing API token from this account.
+   *
+   * @param id The ID of the API token to delete.
+   */
+  async deleteApiToken(id) {
+    await this.requester.makeRawRequest(DeleteApiToken, { api_token_id: id });
+  }
+  /**
+   * Executes a raw `Query` against the Lightspark API.
+   *
+   * This generally should not be used directly, but is exposed for advanced use cases and for internal use to retrieve
+   * complex fields from objects.
+   *
+   * @param query The `Query` to execute.
+   * @returns The result of the query.
+   */
+  executeRawQuery(query) {
+    return this.requester.executeQuery(query);
+  }
+};
+var WALLET_SDK_ENDPOINT = "graphql/server/2023-04-04";
+var client_default = LightsparkClient;
+export {
+  Account_default as Account,
+  AccountToChannelsConnection_default as AccountToChannelsConnection,
+  AccountTokenAuthProvider_default as AccountTokenAuthProvider,
+  BitcoinNetwork_default as BitcoinNetwork,
+  Channel_default as Channel,
+  ChannelStatus_default as ChannelStatus,
+  CurrencyUnit_default as CurrencyUnit,
+  GraphNode_default as GraphNode,
+  HtlcAttemptFailureCode_default as HtlcAttemptFailureCode,
+  IncomingPayment_default as IncomingPayment,
+  IncomingPaymentAttemptStatus_default as IncomingPaymentAttemptStatus,
+  InvoiceType_default as InvoiceType,
+  client_default as LightsparkClient,
+  LightsparkNode_default as LightsparkNode,
+  LightsparkNodePurpose_default as LightsparkNodePurpose,
+  LightsparkNodeStatus_default as LightsparkNodeStatus,
+  Node_default as Node,
+  NodeAddressType_default as NodeAddressType,
+  OutgoingPayment_default as OutgoingPayment,
+  OutgoingPaymentAttempt_default as OutgoingPaymentAttempt,
+  OutgoingPaymentAttemptStatus_default as OutgoingPaymentAttemptStatus,
+  PaymentFailureReason_default as PaymentFailureReason,
+  PaymentRequestStatus_default as PaymentRequestStatus,
+  Permission_default as Permission,
+  RoutingTransactionFailureReason_default as RoutingTransactionFailureReason,
+  TransactionStatus_default as TransactionStatus,
+  TransactionType_default as TransactionType,
+  WebhookEventType_default as WebhookEventType,
+  WithdrawalMode_default as WithdrawalMode,
+  WithdrawalRequest_default as WithdrawalRequest,
+  WithdrawalRequestStatus_default as WithdrawalRequestStatus,
+  getApiTokenQuery,
+  getChannelClosingTransactionQuery,
+  getChannelOpeningTransactionQuery,
+  getDepositQuery,
+  getHopQuery,
+  getIncomingPaymentAttemptQuery,
+  getInvoiceQuery,
+  getLightningTransactionQuery,
+  getOnChainTransactionQuery,
+  getPaymentRequestQuery,
+  getRoutingTransactionQuery,
+  getTransactionQuery,
+  getWithdrawalQuery
+};