@lightsparkdev/lightspark-sdk 0.4.11 → 1.0.0

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   BitcoinNetwork_default,
   ChannelStatus_default,
   Channel_default,
-  CryptoSanctionsScreeningProvider_default,
+  ComplianceProvider_default,
   CurrencyAmountFromJson,
   CurrencyUnit_default,
   FRAGMENT,
@@ -26,8 +26,9 @@ import {
   InvoiceDataFromJson,
   InvoiceFromJson,
   InvoiceType_default,
-  LightsparkNodePurpose_default,
   LightsparkNodeStatus_default,
+  LightsparkNodeWithOSK_default,
+  LightsparkNodeWithRemoteSigning_default,
   LightsparkNode_default,
   NodeAddressType_default,
   Node_default,
@@ -35,11 +36,14 @@ import {
   OutgoingPaymentAttempt_default,
   OutgoingPaymentFromJson,
   OutgoingPayment_default,
+  PaymentDirection_default,
   PaymentFailureReason_default,
   PaymentRequestStatus_default,
   Permission_default,
+  RemoteSigningSubEventType_default,
   RiskRating_default,
   RoutingTransactionFailureReason_default,
+  SignablePayloadStatus_default,
   TransactionFromJson,
   TransactionStatus_default,
   TransactionType_default,
@@ -64,9 +68,11 @@ import {
   getOnChainTransactionQuery,
   getPaymentRequestQuery,
   getRoutingTransactionQuery,
+  getSignablePayloadQuery,
+  getSignableQuery,
   getTransactionQuery,
   getWithdrawalQuery
-} from "./chunk-NXUFC5J7.js";
+} from "./chunk-LZC5C5NI.js";
 import "./chunk-NIMBE7W3.js";
 
 // src/auth/AccountTokenAuthProvider.ts
@@ -102,14 +108,13 @@ var AccountTokenAuthProvider_default = AccountTokenAuthProvider;
 // src/client.ts
 import autoBind2 from "auto-bind";
 import {
-  b64encode as b64encode2,
-  DefaultCrypto,
-  KeyOrAlias,
+  DefaultCrypto as DefaultCrypto2,
   LightsparkAuthException,
   LightsparkException,
-  LightsparkSigningException,
+  LightsparkSigningException as LightsparkSigningException3,
   NodeKeyCache,
   Requester,
+  SigningKeyType as SigningKeyType2,
   StubAuthProvider
 } from "@lightsparkdev/core";
 import { createHash } from "crypto";
@@ -117,7 +122,7 @@ import { createHash } from "crypto";
 // package.json
 var package_default = {
   name: "@lightsparkdev/lightspark-sdk",
-  version: "0.4.11",
+  version: "1.0.0",
   description: "Lightspark JS SDK",
   author: "Lightspark Inc.",
   keywords: [
@@ -136,7 +141,7 @@ var package_default = {
     url: "https://github.com/lightsparkdev/js-sdk/issues"
   },
   engines: {
-    node: ">=14.16"
+    node: ">=18.17.0"
   },
   exports: {
     ".": {
@@ -165,7 +170,9 @@ var package_default = {
   main: "./dist/index.js",
   module: "./dist/index.js",
   browser: {
-    crypto: false
+    crypto: false,
+    fs: false,
+    path: false
   },
   files: [
     "src/*",
@@ -173,7 +180,7 @@ var package_default = {
     "CHANGELOG.md"
   ],
   scripts: {
-    build: "tsup --entry src/index.ts --entry src/objects/index.ts --format cjs,esm --dts",
+    build: "tsup",
     clean: "rm -rf .turbo && rm -rf dist",
     dev: "yarn build -- --watch",
     docs: "typedoc src",
@@ -190,7 +197,7 @@ var package_default = {
   },
   license: "Apache-2.0",
   dependencies: {
-    "@lightsparkdev/core": "0.3.11",
+    "@lightsparkdev/core": "1.0.0",
     "auto-bind": "^5.0.1",
     crypto: "^1.0.1",
     "crypto-browserify": "^3.12.0",
@@ -204,14 +211,14 @@ var package_default = {
     "@lightsparkdev/eslint-config": "*",
     "@lightsparkdev/tsconfig": "0.0.0",
     "@types/crypto-js": "^4.1.1",
-    "@types/jest": "^29.5.2",
+    "@types/jest": "^29.5.3",
     "@types/ws": "^8.5.4",
     eslint: "^8.3.0",
     "eslint-watch": "^8.0.0",
-    jest: "^29.4.1",
+    jest: "^29.6.2",
     prettier: "3.0.2",
     "prettier-plugin-organize-imports": "^3.2.2",
-    "ts-jest": "^29.0.5",
+    "ts-jest": "^29.1.1",
     "ts-node": "^10.9.1",
     "tsc-absolute": "^1.0.1",
     tsup: "^6.7.0",
@@ -258,8 +265,9 @@ var CreateInvoice = `
     $amount_msats: Long!
     $memo: String
     $type: InvoiceType = null
-    ) {
-    create_invoice(input: { node_id: $node_id, amount_msats: $amount_msats, memo: $memo, invoice_type: $type }) {
+    $expiry_secs: Int = null
+  ) {
+    create_invoice(input: { node_id: $node_id, amount_msats: $amount_msats, memo: $memo, invoice_type: $type, expiry_secs: $expiry_secs }) {
       invoice {
         data {
           encoded_payment_request
@@ -275,11 +283,13 @@ mutation CreateLnurlInvoice(
   $node_id: ID!
   $amount_msats: Long!
   $metadata_hash: String!
+  $expiry_secs: Int = null
 ) {
   create_lnurl_invoice(input: {
       node_id: $node_id
       amount_msats: $amount_msats
       metadata_hash: $metadata_hash
+      expiry_secs: $expiry_secs
   }) {
       invoice {
           ...InvoiceFragment
@@ -342,6 +352,28 @@ mutation CreateTestModePayment(
 ${FRAGMENT6}
 `;
 
+// src/graphql/CreateUmaInvoice.ts
+var CreateUmaInvoice = `
+mutation CreateUmaInvoice(
+  $node_id: ID!
+  $amount_msats: Long!
+  $metadata_hash: String!
+  $expiry_secs: Int = null
+) {
+  create_uma_invoice(input: {
+      node_id: $node_id
+      amount_msats: $amount_msats
+      metadata_hash: $metadata_hash
+      expiry_secs: $expiry_secs
+  }) {
+      invoice {
+          ...InvoiceFragment
+      }
+  }
+}
+${FRAGMENT5}
+`;
+
 // src/graphql/DecodeInvoice.ts
 var DecodeInvoice = `
   query DecodeInvoice($encoded_payment_request: String!) {
@@ -440,7 +472,6 @@ var MultiNodeDashboard = `
         entities {
           color
           display_name
-          purpose
           id
           addresses(first: 1) {
             entities {
@@ -526,19 +557,31 @@ var PayInvoice = `
   ${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/PayUmaInvoice.ts
+var PayUmaInvoice = `
+  mutation PayUmaInvoice(
+    $node_id: ID!
+    $encoded_invoice: String!
+    $timeout_secs: Int!
+    $maximum_fees_msats: Long!
+    $amount_msats: Long
+  ) {
+    pay_uma_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/RequestWithdrawal.ts
@@ -613,7 +656,6 @@ query SingleNodeDashboard(
             entities {
                 color
                 display_name
-                purpose
                 id
                 addresses(first: 1) {
                     entities {
@@ -757,6 +799,183 @@ subscription TransactionSubscription(
 ${FRAGMENT10}
 `;
 
+// src/NodeKeyLoaderCache.ts
+import {
+  LightsparkSigningException as LightsparkSigningException2
+} from "@lightsparkdev/core";
+
+// src/SigningKeyLoader.ts
+import {
+  b64encode as b64encode2,
+  LightsparkSigningException,
+  SigningKeyType
+} from "@lightsparkdev/core";
+
+// src/graphql/RecoverNodeSigningKey.ts
+var RecoverNodeSigningKey = `
+  query RecoverNodeSigningKey($nodeId: ID!) {
+    entity(id: $nodeId) {
+      __typename
+      ... on LightsparkNodeWithOSK {
+        encrypted_signing_private_key {
+          encrypted_value
+          cipher
+        }
+      }
+    }
+  }
+`;
+
+// src/SigningKeyLoader.ts
+import {
+  LightsparkSigner,
+  Network
+} from "../src/lightspark_crypto/lightspark_crypto.js";
+var SIGNING_KEY_PATH = "m/5";
+var getCryptoLibNetwork = (bitcoinNetwork) => {
+  switch (bitcoinNetwork) {
+    case BitcoinNetwork_default.MAINNET:
+      return Network.Bitcoin;
+    case BitcoinNetwork_default.TESTNET:
+      return Network.Testnet;
+    case BitcoinNetwork_default.REGTEST:
+      return Network.Regtest;
+    default:
+      throw new Error(
+        `Unsupported lightspark_crypto network ${bitcoinNetwork}.`
+      );
+  }
+};
+function isNodeIdAndPasswordSigningKeyLoaderArgs(args) {
+  return args.password !== void 0;
+}
+function isMasterSeedSigningKeyLoaderArgs(args) {
+  return args.masterSeed !== void 0;
+}
+var NodeIdAndPasswordSigningKeyLoader = class {
+  nodeId;
+  password;
+  requester;
+  cryptoImpl;
+  constructor(args, requester, cryptoImpl) {
+    this.nodeId = args.nodeId;
+    this.password = args.password;
+    this.requester = requester;
+    this.cryptoImpl = cryptoImpl;
+  }
+  async loadSigningKey() {
+    const encryptedKey = await this.recoverNodeSigningKey();
+    if (!encryptedKey) {
+      console.warn("No encrypted key found for node " + this.nodeId);
+      return;
+    }
+    const signingPrivateKey = await this.cryptoImpl.decryptSecretWithNodePassword(
+      encryptedKey.cipher,
+      encryptedKey.encrypted_value,
+      this.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);
+    }
+    return { key: signingPrivateKeyPEM, type: SigningKeyType.RSASigningKey };
+  }
+  async recoverNodeSigningKey() {
+    const response = await this.requester.makeRawRequest(
+      RecoverNodeSigningKey,
+      { nodeId: this.nodeId }
+    );
+    const nodeEntity = response.entity;
+    if (nodeEntity?.__typename === "LightsparkNodeWithOSK") {
+      return nodeEntity.encrypted_signing_private_key;
+    }
+    return null;
+  }
+};
+var MasterSeedSigningKeyLoader = class {
+  masterSeed;
+  network;
+  constructor(args) {
+    this.masterSeed = args.masterSeed;
+    this.network = args.network;
+  }
+  async loadSigningKey() {
+    const lightsparkSigner = LightsparkSigner.from_bytes(
+      this.masterSeed,
+      getCryptoLibNetwork(this.network)
+    );
+    const privateKey = lightsparkSigner.derive_private_key(SIGNING_KEY_PATH);
+    return { key: privateKey, type: SigningKeyType.Secp256k1SigningKey };
+  }
+};
+
+// src/NodeKeyLoaderCache.ts
+var NodeKeyLoaderCache = class {
+  constructor(nodeKeyCache, cryptoImpl = DefaultCrypto) {
+    this.nodeKeyCache = nodeKeyCache;
+    this.cryptoImpl = cryptoImpl;
+    this.idToLoader = /* @__PURE__ */ new Map();
+  }
+  idToLoader;
+  /**
+   * Sets the signing key loader for a node.
+   * Instantiates a signing key loader based on the type of args passed in by the user.
+   *
+   * @param nodeId The ID of the node to get the key for
+   * @param loaderArgs Loader arguments for loading the key
+   * @param requester Requester used for loading the key
+   */
+  setLoader(nodeId, loaderArgs, requester) {
+    let loader;
+    if (isNodeIdAndPasswordSigningKeyLoaderArgs(loaderArgs)) {
+      loader = new NodeIdAndPasswordSigningKeyLoader(
+        { nodeId, ...loaderArgs },
+        requester,
+        this.cryptoImpl
+      );
+    } else if (isMasterSeedSigningKeyLoaderArgs(loaderArgs)) {
+      loader = new MasterSeedSigningKeyLoader({ ...loaderArgs });
+    } else {
+      throw new LightsparkSigningException2("Invalid signing key loader args");
+    }
+    this.idToLoader.set(nodeId, loader);
+  }
+  /**
+   * Gets the key for a node using the loader set by [setLoader]
+   *
+   * @param id The ID of the node to get the key for
+   * @returns The loaded key
+   */
+  async getKeyWithLoader(id) {
+    if (this.nodeKeyCache.hasKey(id)) {
+      return this.nodeKeyCache.getKey(id);
+    }
+    const loader = this.idToLoader.get(id);
+    if (!loader) {
+      throw new LightsparkSigningException2(
+        "No signing key loader found for node " + id
+      );
+    }
+    const loaderResult = await loader.loadSigningKey();
+    if (!loaderResult) {
+      return;
+    }
+    return this.nodeKeyCache.loadKey(
+      id,
+      { key: loaderResult.key },
+      loaderResult.type
+    );
+  }
+};
+
 // src/client.ts
 var sdkVersion = package_default.version;
 var LightsparkClient = class {
@@ -769,14 +988,18 @@ var LightsparkClient = class {
    * @param cryptoImpl The crypto implementation to use. Defaults to web and node compatible crypto.
    *     For React Native, you should use the `ReactNativeCrypto` implementation from `@lightsparkdev/react-native`.
    */
-  constructor(authProvider = new StubAuthProvider(), serverUrl = "api.lightspark.com", cryptoImpl = DefaultCrypto) {
+  constructor(authProvider = new StubAuthProvider(), serverUrl = "api.lightspark.com", cryptoImpl = DefaultCrypto2) {
     this.authProvider = authProvider;
     this.serverUrl = serverUrl;
     this.cryptoImpl = cryptoImpl;
     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,
@@ -786,6 +1009,30 @@ var LightsparkClient = class {
   }
   requester;
   nodeKeyCache;
+  nodeKeyLoaderCache;
+  LIGHTSPARK_SDK_ENDPOINT = process.env.LIGHTSPARK_SDK_ENDPOINT || "graphql/server/2023-09-13";
+  /**
+   * 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
+   */
+  async loadNodeSigningKey(nodeId, loaderArgs) {
+    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
+   */
+  async getNodeSigningKey(nodeId) {
+    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.
@@ -795,7 +1042,7 @@ var LightsparkClient = class {
   async setAuthProvider(authProvider) {
     this.requester = new Requester(
       this.nodeKeyCache,
-      LIGHTSPARK_SDK_ENDPOINT,
+      this.LIGHTSPARK_SDK_ENDPOINT,
       `js-lightspark-sdk/${sdkVersion}`,
       authProvider,
       this.serverUrl,
@@ -889,7 +1136,6 @@ var LightsparkClient = class {
         return {
           color: node.color,
           displayName: node.display_name,
-          purpose: node.purpose,
           id: node.id,
           publicKey: node.public_key,
           status: node.status,
@@ -966,7 +1212,6 @@ var LightsparkClient = class {
     return {
       color: node.color,
       displayName: account.name,
-      purpose: node.purpose,
       id: node.id,
       publicKey: node.public_key,
       status: node.status,
@@ -1005,15 +1250,23 @@ var LightsparkClient = class {
    * @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.
    */
-  async createInvoice(nodeId, amountMsats, memo, type = void 0) {
-    const response = await this.requester.makeRawRequest(CreateInvoice, {
+  async createInvoice(nodeId, amountMsats, memo, type = void 0, expirySecs = void 0) {
+    const variables = {
       node_id: nodeId,
       amount_msats: amountMsats,
       memo,
       type
-    });
+    };
+    if (expirySecs !== void 0) {
+      variables["expiry_secs"] = expirySecs;
+    }
+    const response = await this.requester.makeRawRequest(
+      CreateInvoice,
+      variables
+    );
     return response.create_invoice?.invoice.data?.encoded_payment_request;
   }
   /**
@@ -1028,20 +1281,59 @@ var LightsparkClient = class {
    * @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.
    */
-  async createLnurlInvoice(nodeId, amountMsats, metadata) {
-    const response = await this.requester.makeRawRequest(CreateLnurlInvoice, {
+  async createLnurlInvoice(nodeId, amountMsats, metadata, expirySecs = void 0) {
+    const variables = {
       node_id: nodeId,
       amount_msats: amountMsats,
       metadata_hash: createHash("sha256").update(metadata).digest("hex")
-    });
+    };
+    if (expirySecs !== void 0) {
+      variables["expiry_secs"] = expirySecs;
+    }
+    const response = await this.requester.makeRawRequest(
+      CreateLnurlInvoice,
+      variables
+    );
     const invoiceJson = response.create_lnurl_invoice?.invoice;
     if (!invoiceJson) {
       return void 0;
     }
     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.
+   */
+  async createUmaInvoice(nodeId, amountMsats, metadata, expirySecs = void 0) {
+    const variables = {
+      node_id: nodeId,
+      amount_msats: amountMsats,
+      metadata_hash: createHash("sha256").update(metadata).digest("hex"),
+      expiry_secs: expirySecs !== void 0 ? expirySecs : 3600
+    };
+    const response = await this.requester.makeRawRequest(
+      CreateUmaInvoice,
+      variables
+    );
+    const invoiceJson = response.create_uma_invoice?.invoice;
+    if (!invoiceJson) {
+      return void 0;
+    }
+    return InvoiceFromJson(invoiceJson);
+  }
   /**
    * Decodes an encoded lightning invoice string.
    *
@@ -1112,53 +1404,6 @@ var LightsparkClient = class {
       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.
-   */
-  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 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) {
-      signingPrivateKeyPEM = b64encode2(signingPrivateKey);
-    } else {
-      const dec = new TextDecoder();
-      signingPrivateKeyPEM = dec.decode(signingPrivateKey);
-    }
-    await this.nodeKeyCache.loadKey(
-      nodeId,
-      KeyOrAlias.key(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 or alias.
    *
@@ -1166,7 +1411,11 @@ var LightsparkClient = class {
    * @param signingPrivateKeyPEM The PEM-encoded signing private key.
    */
   async loadNodeKey(nodeId, signingPrivateKeyOrAlias) {
-    await this.nodeKeyCache.loadKey(nodeId, signingPrivateKeyOrAlias);
+    await this.nodeKeyCache.loadKey(
+      nodeId,
+      signingPrivateKeyOrAlias,
+      SigningKeyType2.RSASigningKey
+    );
   }
   /**
    * Sends a lightning payment for a given invoice.
@@ -1186,7 +1435,7 @@ var LightsparkClient = class {
    */
   async payInvoice(payerNodeId, encodedInvoice, maximumFeesMsats, timeoutSecs = 60, amountMsats = void 0) {
     if (!this.nodeKeyCache.hasKey(payerNodeId)) {
-      throw new LightsparkSigningException("Paying node is not unlocked");
+      throw new LightsparkSigningException3("Paying node is not unlocked");
     }
     const variables = {
       node_id: payerNodeId,
@@ -1210,6 +1459,47 @@ var LightsparkClient = class {
     }
     return response.pay_invoice && OutgoingPaymentFromJson(response.pay_invoice.payment);
   }
+  /**
+   * 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.
+   */
+  async payUmaInvoice(payerNodeId, encodedInvoice, maximumFeesMsats, timeoutSecs = 60, amountMsats = void 0) {
+    if (!this.nodeKeyCache.hasKey(payerNodeId)) {
+      throw new LightsparkSigningException3("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(
+      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.
    *
@@ -1224,7 +1514,7 @@ var LightsparkClient = class {
    */
   async sendPayment(payerNodeId, destinationPublicKey, timeoutSecs = 60, amountMsats, maximumFeesMsats) {
     if (!this.nodeKeyCache.hasKey(payerNodeId)) {
-      throw new LightsparkSigningException("Paying node is not unlocked");
+      throw new LightsparkSigningException3("Paying node is not unlocked");
     }
     const response = await this.requester.makeRawRequest(
       SendPayment,
@@ -1405,7 +1695,6 @@ var LightsparkClient = class {
     return this.requester.executeQuery(query);
   }
 };
-var LIGHTSPARK_SDK_ENDPOINT = "graphql/server/2023-04-04";
 var client_default = LightsparkClient;
 
 // src/webhooks.ts
@@ -1441,7 +1730,7 @@ export {
   BitcoinNetwork_default as BitcoinNetwork,
   Channel_default as Channel,
   ChannelStatus_default as ChannelStatus,
-  CryptoSanctionsScreeningProvider_default as CryptoSanctionsScreeningProvider,
+  ComplianceProvider_default as ComplianceProvider,
   CurrencyUnit_default as CurrencyUnit,
   GraphNode_default as GraphNode,
   HtlcAttemptFailureCode_default as HtlcAttemptFailureCode,
@@ -1450,18 +1739,22 @@ export {
   InvoiceType_default as InvoiceType,
   client_default as LightsparkClient,
   LightsparkNode_default as LightsparkNode,
-  LightsparkNodePurpose_default as LightsparkNodePurpose,
   LightsparkNodeStatus_default as LightsparkNodeStatus,
+  LightsparkNodeWithOSK_default as LightsparkNodeWithOSK,
+  LightsparkNodeWithRemoteSigning_default as LightsparkNodeWithRemoteSigning,
   Node_default as Node,
   NodeAddressType_default as NodeAddressType,
   OutgoingPayment_default as OutgoingPayment,
   OutgoingPaymentAttempt_default as OutgoingPaymentAttempt,
   OutgoingPaymentAttemptStatus_default as OutgoingPaymentAttemptStatus,
+  PaymentDirection_default as PaymentDirection,
   PaymentFailureReason_default as PaymentFailureReason,
   PaymentRequestStatus_default as PaymentRequestStatus,
   Permission_default as Permission,
+  RemoteSigningSubEventType_default as RemoteSigningSubEventType,
   RiskRating_default as RiskRating,
   RoutingTransactionFailureReason_default as RoutingTransactionFailureReason,
+  SignablePayloadStatus_default as SignablePayloadStatus,
   TransactionStatus_default as TransactionStatus,
   TransactionType_default as TransactionType,
   WEBHOOKS_SIGNATURE_HEADER,
@@ -1483,6 +1776,8 @@ export {
   getOnChainTransactionQuery,
   getPaymentRequestQuery,
   getRoutingTransactionQuery,
+  getSignablePayloadQuery,
+  getSignableQuery,
   getTransactionQuery,
   getWithdrawalQuery,
   verifyAndParseWebhook