@buildonspark/spark-sdk 0.0.21 → 0.0.22

package/src/examples/example.ts

@@ -1,6 +1,7 @@
 import readline from "readline";
 import { ConfigOptions } from "../../dist/services/wallet-config.js";
 import { SparkWallet } from "../../dist/spark-sdk";
+import { BitcoinNetwork } from "../../dist/types/index.js";
 import { getLatestDepositTxId } from "../../dist/utils/mempool.js";
 
 // Initialize Spark Wallet
@@ -18,23 +19,29 @@ async function runCLI() {
   });
   const helpMessage = `
   Available commands:
-  initwallet [mnemonic | seed]                                    - Create a new wallet from a mnemonic or seed. If no mnemonic or seed is provided, a new mnemonic will be generated.
-  getbalance                                                      - Get the wallet's balance
-  getdepositaddress                                               - Get an address to deposit funds from L1 to Spark
-  getsparkaddress                                                 - Get the wallet's spark address
-  getlatesttx <address>                                           - Get the latest deposit transaction id for an address
-  claimdeposit <txid>                                             - Claim any pending deposits to the wallet
-  claimtransfers                                                 - Claim any pending transfers to the wallet
-  createinvoice <amount> <memo>                                   - Create a new lightning invoice
-  payinvoice <invoice>                                            - Pay a lightning invoice
-  sendtransfer <amount> <receiverSparkAddress>                    - Send a spark transfer
-  withdraw <onchainAddress> <amount>                              - Withdraw funds to an L1 address
-  sendtokentransfer <tokenPubKey> <amount> <receiverSparkAddress> - Transfer tokens
-  help                                                            - Show this help message
+  initwallet [mnemonic | seed]                                        - Create a new wallet from a mnemonic or seed. If no mnemonic or seed is provided, a new mnemonic will be generated.
+  getbalance                                                          - Get the wallet's balance
+  getdepositaddress                                                   - Get an address to deposit funds from L1 to Spark
+  getsparkaddress                                                     - Get the wallet's spark address
+  getlatesttx <address>                                               - Get the latest deposit transaction id for an address
+  claimdeposit <txid>                                                 - Claim any pending deposits to the wallet
+  claimtransfers                                                      - Claim any pending transfers to the wallet
+  createinvoice <amount> <memo>                                       - Create a new lightning invoice
+  payinvoice <invoice>                                                - Pay a lightning invoice
+  sendtransfer <amount> <receiverSparkAddress>                        - Send a spark transfer
+  withdraw <amount> <onchainAddress>                                   - Withdraw funds to an L1 address
+  coopfee <amount> <withdrawalAddress>                                - Get a fee estimate for a cooperative exit
+  lightningsendfee <invoice>                                          - Get a fee estimate for a lightning send
+  lightningreceivefee <amount> <REGTEST | MAINNET | TESTNET | SIGNET> - Get a fee estimate for a lightning receive
+  getlightningsendrequest <requestId>                                 - Get a lightning send request by ID
+  getlightningreceiverequest <requestId>                              - Get a lightning receive request by ID
+  getcoopexitrequest <requestId>                                      - Get a coop exit request by ID
+  sendtokentransfer <tokenPubKey> <amount> <receiverSparkAddress>     - Transfer tokens
+  help                                                                - Show this help message
   exit/quit
 
   L1 commands:
-  tokenwithdraw <tokenPublicKey> [receiverPublicKey] - Unilaterally withdraw tokens to L1- Exit the program
+  tokenwithdraw <tokenPublicKey> [tokenAmount] - Unilaterally withdraw tokens to L1- Exit the program
 `;
   console.log(helpMessage);
 
@@ -67,6 +74,42 @@ async function runCLI() {
         const depositResult = await wallet.claimDeposit(args[0]);
         console.log(depositResult);
         break;
+      case "pendingtransfers":
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const pendingTransfers = await wallet.getPendingTransfers();
+        console.log(pendingTransfers);
+        break;
+      case "getlightningsendrequest":
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const lightningSendRequest = await wallet.getLightningSendRequest(
+          args[0],
+        );
+        console.log(lightningSendRequest);
+        break;
+      case "getlightningreceiverequest":
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const lightningReceiveRequest = await wallet.getLightningReceiveRequest(
+          args[0],
+        );
+        console.log(lightningReceiveRequest);
+        break;
+      case "getcoopexitrequest":
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const coopExitRequest = await wallet.getCoopExitRequest(args[0]);
+        console.log(coopExitRequest);
+        break;
       case "claimtransfers":
         if (!wallet) {
           console.log("Please initialize a wallet first");
@@ -187,8 +230,8 @@ async function runCLI() {
           break;
         }
         const withdrawal = await wallet.withdraw({
-          onchainAddress: args[0],
-          targetAmountSats: parseInt(args[1]),
+          amountSats: parseInt(args[0]),
+          onchainAddress: args[1],
         });
         console.log(withdrawal);
         break;
@@ -198,17 +241,54 @@ async function runCLI() {
           break;
         }
         const tokenPublicKey = args[0];
-        const receiverPublicKey = args[1];
+        const amount = BigInt(parseInt(args[1]));
 
         let withdrawResult = await wallet.withdrawTokens(
           tokenPublicKey,
-          receiverPublicKey,
+          amount,
         );
         if (withdrawResult) {
           console.log("Withdrawal L1 Transaction ID:", withdrawResult.txid);
         }
         break;
       }
+      case "coopfee": {
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const fee = await wallet.getCoopExitFeeEstimate({
+          amountSats: parseInt(args[0]),
+          withdrawalAddress: args[1],
+        });
+
+        console.log(fee);
+        break;
+      }
+      case "lightningsendfee": {
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const fee = await wallet.getLightningSendFeeEstimate({
+          encodedInvoice: args[0],
+        });
+        console.log(fee);
+        break;
+      }
+      case "lightningreceivefee": {
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const network = args[1] as BitcoinNetwork;
+        const fee = await wallet.getLightningReceiveFeeEstimate({
+          amountSats: parseInt(args[0]),
+          network,
+        });
+        console.log(fee);
+        break;
+      }
     }
   }
 }

package/src/graphql/client.ts

@@ -47,6 +47,7 @@ import { CoopExitFeeEstimate } from "./queries/CoopExitFeeEstimate.js";
 import { LeavesSwapFeeEstimate } from "./queries/LeavesSwapFeeEstimate.js";
 import { LightningReceiveFeeEstimate } from "./queries/LightningReceiveFeeEstimate.js";
 import { LightningSendFeeEstimate } from "./queries/LightningSendFeeEstimate.js";
+import { UserRequest } from "./queries/UserRequest.js";
 
 export default class SspClient {
   private readonly requester: Requester;
@@ -267,6 +268,74 @@ export default class SspClient {
       },
     });
   }
+
+  async getLightningReceiveRequest(
+    id: string,
+  ): Promise<LightningReceiveRequest | null> {
+    return await this.executeRawQuery({
+      queryPayload: UserRequest,
+      variables: {
+        request_id: id,
+      },
+      constructObject: (response: { user_request: any }) => {
+        if (!response.user_request) {
+          return null;
+        }
+
+        return LightningReceiveRequestFromJson(response.user_request);
+      },
+    });
+  }
+
+  async getLightningSendRequest(
+    id: string,
+  ): Promise<LightningSendRequest | null> {
+    return await this.executeRawQuery({
+      queryPayload: UserRequest,
+      variables: {
+        request_id: id,
+      },
+      constructObject: (response: { user_request: any }) => {
+        if (!response.user_request) {
+          return null;
+        }
+
+        return LightningSendRequestFromJson(response.user_request);
+      },
+    });
+  }
+
+  async getLeaveSwapRequest(id: string): Promise<LeavesSwapRequest | null> {
+    return await this.executeRawQuery({
+      queryPayload: UserRequest,
+      variables: {
+        request_id: id,
+      },
+      constructObject: (response: { user_request: any }) => {
+        if (!response.user_request) {
+          return null;
+        }
+
+        return LeavesSwapRequestFromJson(response.user_request);
+      },
+    });
+  }
+
+  async getCoopExitRequest(id: string): Promise<CoopExitRequest | null> {
+    return await this.executeRawQuery({
+      queryPayload: UserRequest,
+      variables: {
+        request_id: id,
+      },
+      constructObject: (response: { user_request: any }) => {
+        if (!response.user_request) {
+          return null;
+        }
+
+        return CoopExitRequestFromJson(response.user_request);
+      },
+    });
+  }
 }
 
 class SparkAuthProvider implements AuthProvider {

package/src/graphql/queries/UserRequest.ts

@@ -0,0 +1,10 @@
+import { FRAGMENT as UserRequestFragment } from "../objects/UserRequest.js";
+
+export const UserRequest = `
+  query UserRequest($request_id: ID!) {
+    user_request(request_id: $request_id) {
+      ...UserRequestFragment
+    }
+  }
+  ${UserRequestFragment}
+`;

package/src/services/lightning.ts

@@ -7,6 +7,7 @@ import { secp256k1 } from "@noble/curves/secp256k1";
 import { TransactionInput } from "@scure/btc-signer/psbt";
 import { sha256 } from "@scure/btc-signer/utils";
 import { decode } from "light-bolt11-decoder";
+import LightningReceiveRequest from "../graphql/objects/LightningReceiveRequest.js";
 import {
   GetSigningCommitmentsResponse,
   InitiatePreimageSwapRequest_Reason,
@@ -38,7 +39,7 @@ export type CreateLightningInvoiceParams = {
     amountSats: number,
     paymentHash: Uint8Array,
     memo?: string,
-  ) => Promise<string | undefined>;
+  ) => Promise<LightningReceiveRequest | null>;
   amountSats: number;
   memo?: string;
 };
@@ -71,7 +72,7 @@ export class LightningService {
     invoiceCreator,
     amountSats,
     memo,
-  }: CreateLightningInvoiceParams): Promise<string> {
+  }: CreateLightningInvoiceParams): Promise<LightningReceiveRequest> {
     const randBytes = crypto.getRandomValues(new Uint8Array(32));
     const preimage = numberToBytesBE(
       bytesToNumberBE(randBytes) % secp256k1.CURVE.n,
@@ -90,7 +91,7 @@ export class LightningService {
     amountSats,
     memo,
     preimage,
-  }: CreateLightningInvoiceWithPreimageParams): Promise<string> {
+  }: CreateLightningInvoiceWithPreimageParams): Promise<LightningReceiveRequest> {
     const paymentHash = sha256(preimage);
     const invoice = await invoiceCreator(amountSats, paymentHash, memo);
     if (!invoice) {
@@ -124,7 +125,7 @@ export class LightningService {
               proofs: share.proofs,
             },
             threshold: this.config.getThreshold(),
-            invoiceString: invoice,
+            invoiceString: invoice.invoice.encodedEnvoice,
             userIdentityPublicKey:
               await this.config.signer.getIdentityPublicKey(),
           });

package/src/services/transfer.ts

@@ -1056,7 +1056,7 @@ export class TransferService extends BaseTransferService {
     });
   }
 
-  private async extendTimelock(node: TreeNode, signingPubKey: Uint8Array) {
+  async extendTimelock(node: TreeNode, signingPubKey: Uint8Array) {
     const nodeTx = getTxFromRawTxBytes(node.nodeTx);
     const refundTx = getTxFromRawTxBytes(node.refundTx);
 

package/src/spark-sdk.ts

@@ -11,14 +11,16 @@ import { decode } from "light-bolt11-decoder";
 import SspClient from "./graphql/client.js";
 import {
   BitcoinNetwork,
-  CoopExitFeeEstimateInput,
   CoopExitFeeEstimateOutput,
+  CoopExitRequest,
   LeavesSwapFeeEstimateOutput,
   LeavesSwapRequest,
   LightningReceiveFeeEstimateInput,
   LightningReceiveFeeEstimateOutput,
+  LightningReceiveRequest,
   LightningSendFeeEstimateInput,
   LightningSendFeeEstimateOutput,
+  LightningSendRequest,
   UserLeafInput,
 } from "./graphql/objects/index.js";
 import {
@@ -38,7 +40,11 @@ import { LightningService } from "./services/lightning.js";
 import { TokenTransactionService } from "./services/token-transactions.js";
 import { LeafKeyTweak, TransferService } from "./services/transfer.js";
 import { ConfigOptions } from "./services/wallet-config.js";
-
+import {
+  createLrc20ConnectionManager,
+  ILrc20ConnectionManager,
+  Lrc20SparkClient,
+} from "@buildonspark/lrc20-sdk/grpc";
 import { validateMnemonic } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english";
 import { Mutex } from "async-mutex";
@@ -102,6 +108,14 @@ type DepositParams = {
   vout: number;
 };
 
+export type TokenInfo = {
+  tokenPublicKey: string;
+  tokenName: string;
+  tokenSymbol: string;
+  tokenDecimals: number;
+  tokenSupply: bigint;
+}
+
 export type InitWalletResponse = {
   mnemonic?: string | undefined;
 };
@@ -121,6 +135,7 @@ export class SparkWallet {
   protected config: WalletConfigService;
 
   protected connectionManager: ConnectionManager;
+  protected lrc20ConnectionManager: ILrc20ConnectionManager;
   protected lrc20Wallet: LRCWallet | undefined;
 
   private depositService: DepositService;
@@ -147,6 +162,7 @@ export class SparkWallet {
   protected constructor(options?: ConfigOptions, signer?: SparkSigner) {
     this.config = new WalletConfigService(options, signer);
     this.connectionManager = new ConnectionManager(this.config);
+    this.lrc20ConnectionManager = createLrc20ConnectionManager(this.config.getLrc20Address());
     this.depositService = new DepositService(
       this.config,
       this.connectionManager,
@@ -327,7 +343,7 @@ export class SparkWallet {
     this.leaves = await this.getLeaves();
     await this.config.signer.restoreSigningKeysFromLeafs(this.leaves);
     await this.refreshTimelockNodes();
-
+    await this.extendTimeLockNodes();
     this.optimizeLeaves().catch((e) => {
       console.error("Failed to optimize leaves", e);
     });
@@ -671,6 +687,25 @@ export class SparkWallet {
     return await this.transferService.queryAllTransfers(limit, offset);
   }
 
+  public async getTokenInfo(): Promise<TokenInfo[]> {
+    await this.syncTokenLeaves();
+
+    const lrc20Client = await this.lrc20ConnectionManager.createLrc20Client();
+    const { balance, tokenBalances } = await this.getBalance();
+    
+    const tokenInfo = await lrc20Client.getTokenPubkeyInfo({
+      publicKeys: Array.from(tokenBalances.keys()).map(hexToBytes)
+    });
+
+    return tokenInfo.tokenPubkeyInfos.map((info) => ({
+      tokenPublicKey: bytesToHex(info.announcement!.publicKey!.publicKey),
+      tokenName: info.announcement!.name,
+      tokenSymbol: info.announcement!.symbol,
+      tokenDecimals: Number(bytesToNumberBE(info.announcement!.decimal)),
+      tokenSupply: bytesToNumberBE(info.totalSupply),
+    }));
+  }
+
   /**
    * Gets the current balance of the wallet.
    * You can use the forceRefetch option to synchronize your wallet and claim any
@@ -900,6 +935,7 @@ export class SparkWallet {
       const leavesToSend = await this.selectLeaves(amountSats);
 
       await this.refreshTimelockNodes();
+      await this.extendTimeLockNodes();
 
       const leafKeyTweaks = await Promise.all(
         leavesToSend.map(async (leaf) => ({
@@ -923,6 +959,29 @@ export class SparkWallet {
     });
   }
 
+  private async extendTimeLockNodes() {
+    const nodesToExtend: TreeNode[] = [];
+    const nodeIds: string[] = [];
+
+    for (const node of this.leaves) {
+      const nodeTx = getTxFromRawTxBytes(node.nodeTx);
+      const { nextSequence } = getNextTransactionSequence(
+        nodeTx.getInput(0).sequence,
+      );
+      if (nextSequence <= 0) {
+        nodesToExtend.push(node);
+        nodeIds.push(node.id);
+      }
+    }
+
+    for (const node of nodesToExtend) {
+      await this.transferService.extendTimelock(
+        node,
+        await this.config.signer.generatePublicKey(sha256(node.id)),
+      );
+    }
+  }
+
   /**
    * Internal method to refresh timelock nodes.
    *
@@ -1056,6 +1115,7 @@ export class SparkWallet {
 
       this.leaves.push(...response.nodes);
       await this.refreshTimelockNodes();
+      await this.extendTimeLockNodes();
 
       return response.nodes;
     });
@@ -1120,13 +1180,13 @@ export class SparkWallet {
    * @param {number} params.amountSats - Amount in satoshis
    * @param {string} params.memo - Description for the invoice
    * @param {number} [params.expirySeconds] - Optional expiry time in seconds
-   * @returns {Promise<string>} BOLT11 encoded invoice
+   * @returns {Promise<LightningReceiveRequest>} BOLT11 encoded invoice
    */
   public async createLightningInvoice({
     amountSats,
     memo,
     expirySeconds = 60 * 60 * 24 * 30,
-  }: CreateLightningInvoiceParams) {
+  }: CreateLightningInvoiceParams): Promise<LightningReceiveRequest> {
     if (!this.sspClient) {
       throw new Error("SSP client not initialized");
     }
@@ -1152,14 +1212,16 @@ export class SparkWallet {
         memo,
       });
 
-      return invoice?.invoice.encodedEnvoice;
+      return invoice;
     };
 
-    return this.lightningService!.createLightningInvoice({
+    const invoice = await this.lightningService!.createLightningInvoice({
       amountSats,
       memo,
       invoiceCreator: requestLightningInvoice,
     });
+
+    return invoice;
   }
 
   /**
@@ -1199,6 +1261,8 @@ export class SparkWallet {
       const leaves = await this.selectLeaves(amountSats);
 
       await this.refreshTimelockNodes();
+      await this.extendTimeLockNodes();
+
       const leavesToSend = await Promise.all(
         leaves.map(async (leaf) => ({
           leaf,
@@ -1354,21 +1418,21 @@ export class SparkWallet {
    *
    * @param {Object} params - Parameters for the withdrawal
    * @param {string} params.onchainAddress - The Bitcoin address where the funds should be sent
-   * @param {number} [params.targetAmountSats] - The amount in satoshis to withdraw. If not specified, attempts to withdraw all available funds
+   * @param {number} [params.amountSats] - The amount in satoshis to withdraw. If not specified, attempts to withdraw all available funds
    * @returns {Promise<CoopExitRequest | null | undefined>} The withdrawal request details, or null/undefined if the request cannot be completed
    */
   public async withdraw({
     onchainAddress,
-    targetAmountSats,
+    amountSats,
   }: {
     onchainAddress: string;
-    targetAmountSats?: number;
+    amountSats?: number;
   }) {
-    if (targetAmountSats && targetAmountSats < 10000) {
+    if (amountSats && amountSats < 10000) {
       throw new Error("The minimum amount for a withdrawal is 10000 sats");
     }
     return await this.withLeaves(async () => {
-      return await this.coopExit(onchainAddress, targetAmountSats);
+      return await this.coopExit(onchainAddress, amountSats);
     });
   }
 
@@ -1454,19 +1518,30 @@ export class SparkWallet {
   /**
    * Gets fee estimate for cooperative exit (on-chain withdrawal).
    *
-   * @param {CoopExitFeeEstimateInput} params - Input parameters for fee estimation
+   * @param {Object} params - Input parameters for fee estimation
+   * @param {number} params.amountSats - The amount in satoshis to withdraw
+   * @param {string} params.withdrawalAddress - The Bitcoin address where the funds should be sent
    * @returns {Promise<CoopExitFeeEstimateOutput | null>} Fee estimate for the withdrawal
    */
   public async getCoopExitFeeEstimate({
-    leafExternalIds,
+    amountSats,
     withdrawalAddress,
-  }: CoopExitFeeEstimateInput): Promise<CoopExitFeeEstimateOutput | null> {
+  }: {
+    amountSats: number;
+    withdrawalAddress: string;
+  }): Promise<CoopExitFeeEstimateOutput | null> {
     if (!this.sspClient) {
       throw new Error("SSP client not initialized");
     }
 
+    if (amountSats < 10000) {
+      throw new Error("The minimum amount for a withdrawal is 10000 sats");
+    }
+
+    const leaves = await this.selectLeaves(amountSats);
+
     return await this.sspClient.getCoopExitFeeEstimate({
-      leafExternalIds,
+      leafExternalIds: leaves.map((leaf) => leaf.id),
       withdrawalAddress,
     });
   }
@@ -1782,4 +1857,50 @@ export class SparkWallet {
       await this.config.signer.signMessageWithIdentityKey(hash, compact),
     );
   }
+
+  /**
+   * Get a Lightning receive request by ID.
+   *
+   * @param {string} id - The ID of the Lightning receive request
+   * @returns {Promise<LightningReceiveRequest | null>} The Lightning receive request
+   */
+  public async getLightningReceiveRequest(
+    id: string,
+  ): Promise<LightningReceiveRequest | null> {
+    if (!this.sspClient) {
+      throw new Error("SSP client not initialized");
+    }
+
+    return await this.sspClient.getLightningReceiveRequest(id);
+  }
+
+  /**
+   * Get a Lightning send request by ID.
+   *
+   * @param {string} id - The ID of the Lightning send request
+   * @returns {Promise<LightningSendRequest | null>} The Lightning send request
+   */
+  public async getLightningSendRequest(
+    id: string,
+  ): Promise<LightningSendRequest | null> {
+    if (!this.sspClient) {
+      throw new Error("SSP client not initialized");
+    }
+
+    return await this.sspClient.getLightningSendRequest(id);
+  }
+
+  /**
+   * Get a coop exit request by ID.
+   *
+   * @param {string} id - The ID of the coop exit request
+   * @returns {Promise<CoopExitRequest | null>} The coop exit request
+   */
+  public async getCoopExitRequest(id: string): Promise<CoopExitRequest | null> {
+    if (!this.sspClient) {
+      throw new Error("SSP client not initialized");
+    }
+
+    return await this.sspClient.getCoopExitRequest(id);
+  }
 }

package/src/tests/lightning.test.ts

@@ -1,11 +1,17 @@
 import { afterEach, beforeAll, describe, expect, it } from "@jest/globals";
 import { hexToBytes } from "@noble/curves/abstract/utils";
 import { equalBytes, sha256 } from "@scure/btc-signer/utils";
+import LightningReceiveRequest from "../graphql/objects/LightningReceiveRequest.js";
 import { TransferStatus } from "../proto/spark.js";
 import { WalletConfigService } from "../services/config.js";
 import { ConnectionManager } from "../services/connection.js";
 import { LightningService } from "../services/lightning.js";
 import { LeafKeyTweak, TransferService } from "../services/transfer.js";
+import {
+  BitcoinNetwork,
+  CurrencyUnit,
+  LightningReceiveRequestStatus,
+} from "../types/index.js";
 import { createNewTree, getTestWalletConfig } from "./test-util.js";
 import { SparkWalletTesting } from "./utils/spark-testing-wallet.js";
 import { BitcoinFaucet } from "./utils/test-faucet.js";
@@ -27,8 +33,38 @@ async function cleanUp() {
   }
 }
 
-const fakeInvoiceCreator = async () => {
-  return "lnbcrt123450n1pnj6uf4pp5l26hsdxssmr52vd4xmn5xran7puzx34hpr6uevaq7ta0ayzrp8esdqqcqzpgxqyz5vqrzjqtr2vd60g57hu63rdqk87u3clac6jlfhej4kldrrjvfcw3mphcw8sqqqqzp3jlj6zyqqqqqqqqqqqqqq9qsp5w22fd8aqn7sdum7hxdf59ptgk322fkv589ejxjltngvgehlcqcyq9qxpqysgqvykwsxdx64qrj0s5pgcgygmrpj8w25jsjgltwn09yp24l9nvghe3dl3y0ycy70ksrlqmcn42hxn24e0ucuy3g9fjltudvhv4lrhhamgq3stqgp";
+const fakeInvoiceCreator = async (): Promise<LightningReceiveRequest> => {
+  return {
+    id: "123",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    network: BitcoinNetwork.REGTEST,
+    fee: {
+      originalValue: 1000,
+      originalUnit: CurrencyUnit.SATOSHI,
+      preferredCurrencyUnit: CurrencyUnit.SATOSHI,
+      preferredCurrencyValueRounded: 1000,
+      preferredCurrencyValueApprox: 1000,
+    },
+    status: LightningReceiveRequestStatus.INVOICE_CREATED,
+    typename: "LightningReceiveRequest",
+    invoice: {
+      encodedEnvoice:
+        "lnbcrt123450n1pnj6uf4pp5l26hsdxssmr52vd4xmn5xran7puzx34hpr6uevaq7ta0ayzrp8esdqqcqzpgxqyz5vqrzjqtr2vd60g57hu63rdqk87u3clac6jlfhej4kldrrjvfcw3mphcw8sqqqqzp3jlj6zyqqqqqqqqqqqqqq9qsp5w22fd8aqn7sdum7hxdf59ptgk322fkv589ejxjltngvgehlcqcyq9qxpqysgqvykwsxdx64qrj0s5pgcgygmrpj8w25jsjgltwn09yp24l9nvghe3dl3y0ycy70ksrlqmcn42hxn24e0ucuy3g9fjltudvhv4lrhhamgq3stqgp",
+      bitcoinNetwork: BitcoinNetwork.REGTEST,
+      paymentHash:
+        "2d059c3ede82a107aa1452c0bea47759be3c5c6e5342be6a310f6c3a907d9f4c",
+      amount: {
+        originalValue: 10000,
+        originalUnit: CurrencyUnit.SATOSHI,
+        preferredCurrencyUnit: CurrencyUnit.SATOSHI,
+        preferredCurrencyValueRounded: 10000,
+        preferredCurrencyValueApprox: 10000,
+      },
+      createdAt: new Date().toISOString(),
+      expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24).toISOString(),
+    },
+  };
 };
 
 describe("LightningService", () => {
@@ -244,7 +280,7 @@ describe("LightningService", () => {
         receiverIdentityPubkey: await sspConfig.signer.getIdentityPublicKey(),
         paymentHash,
         isInboundPayment: false,
-        invoiceString: await fakeInvoiceCreator(),
+        invoiceString: (await fakeInvoiceCreator()).invoice.encodedEnvoice,
       });
 
       expect(response.transfer).toBeDefined();