@buildonspark/spark-sdk 0.0.15 → 0.0.16

package/src/examples/example.ts

@@ -0,0 +1,207 @@
+import readline from "readline";
+import { ConfigOptions } from "../../dist/services/wallet-config.js";
+import { SparkWallet } from "../../dist/spark-sdk";
+import { getLatestDepositTxId } from "../../dist/utils/mempool.js";
+
+// Initialize Spark Wallet
+const walletMnemonic =
+  "cctypical stereo dose party penalty decline neglect feel harvest abstract stage winter";
+
+async function runCLI() {
+  // Get network from command line args
+  const network = process.argv.includes("mainnet") ? "MAINNET" : "REGTEST";
+  let wallet: SparkWallet | undefined;
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  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
+  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
+  exit/quit
+
+  L1 commands:
+  tokenwithdraw <tokenPublicKey> [receiverPublicKey] - Unilaterally withdraw tokens to L1- Exit the program
+`;
+  console.log(helpMessage);
+
+  while (true) {
+    const command = await new Promise<string>((resolve) => {
+      rl.question("> ", resolve);
+    });
+
+    const [firstWord, ...args] = command.split(" ");
+    const lowerCommand = firstWord.toLowerCase();
+
+    if (lowerCommand === "exit" || lowerCommand === "quit") {
+      rl.close();
+      break;
+    }
+
+    switch (lowerCommand) {
+      case "help":
+        console.log(helpMessage);
+        break;
+      case "getlatesttx":
+        const latestTx = await getLatestDepositTxId(args[0]);
+        console.log(latestTx);
+        break;
+      case "claimdeposit":
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const depositResult = await wallet.claimDeposit(args[0]);
+        console.log(depositResult);
+        break;
+      case "initwallet":
+        const mnemonicOrSeed = args.join(" ");
+        const options: ConfigOptions = {
+          network: "REGTEST",
+        };
+        const { wallet: newWallet, mnemonic: newMnemonic } =
+          await SparkWallet.create({
+            mnemonicOrSeed,
+            options,
+          });
+        wallet = newWallet;
+        console.log("Mnemonic:", newMnemonic);
+        break;
+      case "getbalance":
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const balanceInfo = await wallet.getBalance(true);
+        console.log("Sats Balance: " + balanceInfo.balance);
+        if (balanceInfo.tokenBalances && balanceInfo.tokenBalances.size > 0) {
+          console.log("\nToken Balances:");
+          for (const [
+            tokenPublicKey,
+            tokenInfo,
+          ] of balanceInfo.tokenBalances.entries()) {
+            console.log(`  Token (${tokenPublicKey}):`);
+            console.log(`    Balance: ${tokenInfo.balance}`);
+          }
+        }
+        break;
+      case "getdepositaddress":
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const depositAddress = await wallet.getDepositAddress();
+        console.log(depositAddress);
+        break;
+      case "getsparkaddress":
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const sparkAddress = await wallet.getSparkAddress();
+        console.log(sparkAddress);
+        break;
+      case "createinvoice":
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const invoice = await wallet.createLightningInvoice({
+          amountSats: parseInt(args[0]),
+          memo: args[1],
+        });
+        console.log(invoice);
+        break;
+      case "payinvoice":
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const payment = await wallet.payLightningInvoice({
+          invoice: args[0],
+        });
+        console.log(payment);
+        break;
+      case "sendtransfer":
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const transfer = await wallet.sendSparkTransfer({
+          amountSats: parseInt(args[0]),
+          receiverSparkAddress: args[1],
+        });
+        console.log(transfer);
+        break;
+      case "sendtokentransfer":
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        if (args.length < 3) {
+          console.log(
+            "Usage: sendtokentransfer <tokenPubKey> <amount> <receiverPubKey>",
+          );
+          break;
+        }
+
+        const tokenPubKey = args[0];
+        const tokenAmount = BigInt(parseInt(args[1]));
+        const tokenReceiverPubKey = args[2];
+
+        try {
+          const result = await wallet.transferTokens({
+            tokenPublicKey: tokenPubKey,
+            tokenAmount: tokenAmount,
+            receiverSparkAddress: tokenReceiverPubKey,
+          });
+          console.log(result);
+        } catch (error) {
+          console.error("Failed to transfer tokens:", error.message);
+        }
+        break;
+      case "withdraw":
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const withdrawal = await wallet.withdraw({
+          onchainAddress: args[0],
+          targetAmountSats: parseInt(args[1]),
+        });
+        console.log(withdrawal);
+        break;
+      case "tokenwithdraw": {
+        if (!wallet) {
+          console.log("Please initialize a wallet first");
+          break;
+        }
+        const tokenPublicKey = args[0];
+        const receiverPublicKey = args[1];
+
+        let withdrawResult = await wallet.withdrawTokens(
+          tokenPublicKey,
+          receiverPublicKey,
+        );
+        if (withdrawResult) {
+          console.log("Withdrawal L1 Transaction ID:", withdrawResult.txid);
+        }
+        break;
+      }
+    }
+  }
+}
+
+runCLI();

package/src/graphql/client.ts

@@ -0,0 +1,282 @@
+import {
+  AuthProvider,
+  DefaultCrypto,
+  NodeKeyCache,
+  Query,
+  Requester,
+  SigningKey,
+} from "@lightsparkdev/core";
+import { CompleteCoopExit } from "./mutations/CompleteCoopExit.js";
+import { CompleteLeavesSwap } from "./mutations/CompleteLeavesSwap.js";
+import { RequestCoopExit } from "./mutations/RequestCoopExit.js";
+import { RequestLightningReceive } from "./mutations/RequestLightningReceive.js";
+import { RequestLightningSend } from "./mutations/RequestLightningSend.js";
+import { RequestSwapLeaves } from "./mutations/RequestSwapLeaves.js";
+import { CoopExitFeeEstimateOutputFromJson } from "./objects/CoopExitFeeEstimateOutput.js";
+import CoopExitRequest, {
+  CoopExitRequestFromJson,
+} from "./objects/CoopExitRequest.js";
+import {
+  BitcoinNetwork,
+  CompleteCoopExitInput,
+  CompleteLeavesSwapInput,
+  CoopExitFeeEstimateInput,
+  CoopExitFeeEstimateOutput,
+  LightningSendRequest,
+  RequestCoopExitInput,
+  RequestLeavesSwapInput,
+  RequestLightningReceiveInput,
+  RequestLightningSendInput,
+} from "./objects/index.js";
+import LeavesSwapRequest, {
+  LeavesSwapRequestFromJson,
+} from "./objects/LeavesSwapRequest.js";
+import LightningReceiveFeeEstimateOutput, {
+  LightningReceiveFeeEstimateOutputFromJson,
+} from "./objects/LightningReceiveFeeEstimateOutput.js";
+import LightningReceiveRequest, {
+  LightningReceiveRequestFromJson,
+} from "./objects/LightningReceiveRequest.js";
+import LightningSendFeeEstimateOutput, {
+  LightningSendFeeEstimateOutputFromJson,
+} from "./objects/LightningSendFeeEstimateOutput.js";
+import { LightningSendRequestFromJson } from "./objects/LightningSendRequest.js";
+import { CoopExitFeeEstimate } from "./queries/CoopExitFeeEstimate.js";
+import { LightningReceiveFeeEstimate } from "./queries/LightningReceiveFeeEstimate.js";
+import { LightningSendFeeEstimate } from "./queries/LightningSendFeeEstimate.js";
+
+export default class SspClient {
+  private readonly requester: Requester;
+  private identityPublicKey: string;
+  private readonly signingKey?: SigningKey;
+
+  constructor(identityPublicKey: string) {
+    this.identityPublicKey = identityPublicKey;
+
+    const fetchFunction =
+      typeof window !== "undefined" ? window.fetch.bind(window) : fetch;
+
+    this.requester = new Requester(
+      new NodeKeyCache(DefaultCrypto),
+      "graphql/spark/rc",
+      `spark-sdk/0.0.0`,
+      new SparkAuthProvider(identityPublicKey),
+      "https://api.dev.dev.sparkinfra.net",
+      DefaultCrypto,
+      this.signingKey,
+      fetchFunction,
+    );
+  }
+
+  async executeRawQuery<T>(query: Query<T>): Promise<T | null> {
+    return await this.requester.executeQuery(query);
+  }
+
+  async getLightningReceiveFeeEstimate(
+    amountSats: number,
+    network: BitcoinNetwork,
+  ): Promise<LightningReceiveFeeEstimateOutput | null> {
+    return await this.executeRawQuery({
+      queryPayload: LightningReceiveFeeEstimate,
+      variables: {
+        amount_sats: amountSats,
+        network: network,
+      },
+      constructObject: (response: { lightning_receive_fee_estimate: any }) => {
+        return LightningReceiveFeeEstimateOutputFromJson(
+          response.lightning_receive_fee_estimate,
+        );
+      },
+    });
+  }
+
+  async getLightningSendFeeEstimate(
+    encodedInvoice: string,
+  ): Promise<LightningSendFeeEstimateOutput | null> {
+    return await this.executeRawQuery({
+      queryPayload: LightningSendFeeEstimate,
+      variables: {
+        encoded_invoice: encodedInvoice,
+      },
+      constructObject: (response: { lightning_send_fee_estimate: any }) => {
+        return LightningSendFeeEstimateOutputFromJson(
+          response.lightning_send_fee_estimate,
+        );
+      },
+    });
+  }
+
+  async getCoopExitFeeEstimate({
+    leafExternalIds,
+    withdrawalAddress,
+  }: CoopExitFeeEstimateInput): Promise<CoopExitFeeEstimateOutput | null> {
+    return await this.executeRawQuery({
+      queryPayload: CoopExitFeeEstimate,
+      variables: {
+        leaf_external_ids: leafExternalIds,
+        withdrawal_address: withdrawalAddress,
+      },
+      constructObject: (response: { coop_exit_fee_estimate: any }) => {
+        return CoopExitFeeEstimateOutputFromJson(
+          response.coop_exit_fee_estimate,
+        );
+      },
+    });
+  }
+
+  // TODO: Might not need
+  async getCurrentUser() {
+    throw new Error("Not implemented");
+  }
+
+  async completeCoopExit({
+    userOutboundTransferExternalId,
+    coopExitRequestId,
+  }: CompleteCoopExitInput): Promise<CoopExitRequest | null> {
+    return await this.executeRawQuery({
+      queryPayload: CompleteCoopExit,
+      variables: {
+        user_outbound_transfer_external_id: userOutboundTransferExternalId,
+        coop_exit_request_id: coopExitRequestId,
+      },
+      constructObject: (response: { complete_coop_exit: any }) => {
+        return CoopExitRequestFromJson(response.complete_coop_exit.request);
+      },
+    });
+  }
+
+  async requestCoopExit({
+    leafExternalIds,
+    withdrawalAddress,
+  }: RequestCoopExitInput): Promise<CoopExitRequest | null> {
+    return await this.executeRawQuery({
+      queryPayload: RequestCoopExit,
+      variables: {
+        leaf_external_ids: leafExternalIds,
+        withdrawal_address: withdrawalAddress,
+      },
+      constructObject: (response: { request_coop_exit: any }) => {
+        return CoopExitRequestFromJson(response.request_coop_exit.request);
+      },
+    });
+  }
+
+  // TODO: Lets name this better
+  async requestLightningReceive({
+    amountSats,
+    network,
+    paymentHash,
+    expirySecs,
+    memo,
+  }: RequestLightningReceiveInput): Promise<LightningReceiveRequest | null> {
+    return await this.executeRawQuery({
+      queryPayload: RequestLightningReceive,
+      variables: {
+        amount_sats: amountSats,
+        network: network,
+        payment_hash: paymentHash,
+        expiry_secs: expirySecs,
+        memo: memo,
+      },
+      constructObject: (response: { request_lightning_receive: any }) => {
+        return LightningReceiveRequestFromJson(
+          response.request_lightning_receive.request,
+        );
+      },
+    });
+  }
+
+  async requestLightningSend({
+    encodedInvoice,
+    idempotencyKey,
+  }: RequestLightningSendInput): Promise<LightningSendRequest | null> {
+    return await this.executeRawQuery({
+      queryPayload: RequestLightningSend,
+      variables: {
+        encoded_invoice: encodedInvoice,
+        idempotency_key: idempotencyKey,
+      },
+      constructObject: (response: { request_lightning_send: any }) => {
+        return LightningSendRequestFromJson(
+          response.request_lightning_send.request,
+        );
+      },
+    });
+  }
+
+  async requestLeaveSwap({
+    adaptorPubkey,
+    totalAmountSats,
+    targetAmountSats,
+    feeSats,
+    userLeaves,
+  }: RequestLeavesSwapInput): Promise<LeavesSwapRequest | null> {
+    const query = {
+      queryPayload: RequestSwapLeaves,
+      variables: {
+        adaptor_pubkey: adaptorPubkey,
+        total_amount_sats: totalAmountSats,
+        target_amount_sats: targetAmountSats,
+        fee_sats: feeSats,
+        user_leaves: userLeaves,
+      },
+      constructObject: (response: { request_leaves_swap: any }) => {
+        if (!response.request_leaves_swap) {
+          return null;
+        }
+
+        return LeavesSwapRequestFromJson(response.request_leaves_swap.request);
+      },
+    };
+    return await this.executeRawQuery(query);
+  }
+
+  async completeLeaveSwap({
+    adaptorSecretKey,
+    userOutboundTransferExternalId,
+    leavesSwapRequestId,
+  }: CompleteLeavesSwapInput): Promise<LeavesSwapRequest | null> {
+    return await this.executeRawQuery({
+      queryPayload: CompleteLeavesSwap,
+      variables: {
+        adaptor_secret_key: adaptorSecretKey,
+        user_outbound_transfer_external_id: userOutboundTransferExternalId,
+        leaves_swap_request_id: leavesSwapRequestId,
+      },
+      constructObject: (response: { complete_leaves_swap: any }) => {
+        return LeavesSwapRequestFromJson(response.complete_leaves_swap.request);
+      },
+    });
+  }
+}
+
+class SparkAuthProvider implements AuthProvider {
+  private publicKey: string;
+
+  constructor(publicKey: string) {
+    this.publicKey = publicKey;
+  }
+
+  async addAuthHeaders(
+    headers: Record<string, string>,
+  ): Promise<Record<string, string>> {
+    const _headers = {
+      "Spark-Identity-Public-Key": this.publicKey,
+      "Content-Type": "application/json",
+    };
+    return Promise.resolve(_headers);
+  }
+
+  async isAuthorized(): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+
+  async addWsConnectionParams(
+    params: Record<string, unknown>,
+  ): Promise<Record<string, unknown>> {
+    return Promise.resolve({
+      ...params,
+      "Spark-Identity-Public-Key": this.publicKey,
+    });
+  }
+}

package/src/graphql/mutations/CompleteCoopExit.ts

@@ -0,0 +1,19 @@
+import { FRAGMENT as CompleteCoopExitOutputFragment } from "../objects/CoopExitRequest.js";
+
+export const CompleteCoopExit = `
+  mutation CompleteCoopExit(
+    $user_outbound_transfer_external_id: UUID!
+    $coop_exit_request_id: ID!
+  ) {
+    complete_coop_exit(input: {
+      user_outbound_transfer_external_id: $user_outbound_transfer_external_id
+      coop_exit_request_id: $coop_exit_request_id
+    }) {
+      request {
+        ...CoopExitRequestFragment
+      }
+    }
+  }
+    
+  ${CompleteCoopExitOutputFragment}
+`;

package/src/graphql/mutations/CompleteLeavesSwap.ts

@@ -0,0 +1,17 @@
+import { FRAGMENT as LeavesSwapRequestFragment } from "../objects/LeavesSwapRequest.js";
+
+export const CompleteLeavesSwap = `
+  mutation CompleteLeavesSwap(
+    $adaptor_secret_key: String!
+    $user_outbound_transfer_external_id: UUID!
+    $leaves_swap_request_id: ID!
+  ) {
+    complete_leaves_swap(input: { adaptor_secret_key: $adaptor_secret_key, user_outbound_transfer_external_id: $user_outbound_transfer_external_id, leaves_swap_request_id: $leaves_swap_request_id }) {
+      request {
+        ...LeavesSwapRequestFragment
+      }
+    }
+  }
+
+  ${LeavesSwapRequestFragment}
+`;

package/src/graphql/mutations/RequestCoopExit.ts

@@ -0,0 +1,20 @@
+import { FRAGMENT as RequestCoopExitOutputFragment } from "../objects/CoopExitRequest.js";
+
+export const RequestCoopExit = `
+  mutation RequestCoopExit(
+    $leaf_external_ids: [UUID!]!
+    $withdrawal_address: String!
+  ) {
+    request_coop_exit(
+      input: {
+        leaf_external_ids: $leaf_external_ids
+        withdrawal_address: $withdrawal_address
+      }
+    ) {
+      request {
+        ...CoopExitRequestFragment
+      }
+    }
+  }
+  ${RequestCoopExitOutputFragment}
+`;

package/src/graphql/mutations/RequestLightningReceive.ts

@@ -0,0 +1,26 @@
+import { FRAGMENT as RequestLightningReceiveOutputFragment } from "../objects/LightningReceiveRequest.js";
+
+export const RequestLightningReceive = `
+  mutation RequestLightningReceive(
+    $network: BitcoinNetwork!
+    $amount_sats: Long!
+    $payment_hash: Hash32!
+    $expiry_secs: Int
+    $memo: String
+  ) {
+    request_lightning_receive(
+      input: {
+        network: $network
+        amount_sats: $amount_sats
+        payment_hash: $payment_hash
+        expiry_secs: $expiry_secs
+        memo: $memo
+      }
+    ) {
+      request {
+        ...LightningReceiveRequestFragment
+      }
+    }
+  }
+  ${RequestLightningReceiveOutputFragment}
+`;

package/src/graphql/mutations/RequestLightningSend.ts

@@ -0,0 +1,17 @@
+import { FRAGMENT as RequestLightningSendOutputFragment } from "../objects/LightningSendRequest.js";
+export const RequestLightningSend = `
+  mutation RequestLightningSend(
+    $encoded_invoice: String!
+    $idempotency_key: String!
+  ) {
+    request_lightning_send(input: {
+      encoded_invoice: $encoded_invoice
+      idempotency_key: $idempotency_key
+    }) {
+      request {
+        ...LightningSendRequestFragment
+      }
+    }
+  }
+  ${RequestLightningSendOutputFragment}
+`;

package/src/graphql/mutations/RequestSwapLeaves.ts

@@ -0,0 +1,24 @@
+import { FRAGMENT as LeavesSwapRequestFragment } from "../objects/LeavesSwapRequest.js";
+
+export const RequestSwapLeaves = `
+  mutation RequestSwapLeaves(
+    $adaptor_pubkey: String!
+    $total_amount_sats: Long!
+    $target_amount_sats: Long!
+    $fee_sats: Long!
+    $user_leaves: [UserLeafInput!]!
+  ) {
+    request_leaves_swap(input: {
+      adaptor_pubkey: $adaptor_pubkey
+      total_amount_sats: $total_amount_sats
+      target_amount_sats: $target_amount_sats
+      fee_sats: $fee_sats
+      user_leaves: $user_leaves
+    }) {
+      request {
+        ...LeavesSwapRequestFragment
+      }
+    }
+  }
+  ${LeavesSwapRequestFragment}
+`;

package/src/graphql/objects/BitcoinNetwork.ts

@@ -0,0 +1,22 @@
+
+// Copyright ©, 2023-present, Lightspark Group, Inc. - All Rights Reserved
+
+/** This is an enum identifying a particular Bitcoin Network. **/
+export enum BitcoinNetwork { 
+/**
+ * This is an enum value that represents values that could be added in the future.
+ * Clients should support unknown values as more of them could be added without notice.
+ */
+ FUTURE_VALUE = "FUTURE_VALUE",
+/** The production version of the Bitcoin Blockchain. **/
+MAINNET = "MAINNET",
+/** A test version of the Bitcoin Blockchain, maintained by Lightspark. **/
+REGTEST = "REGTEST",
+/** A test version of the Bitcoin Blockchain, maintained by a centralized organization. Not in use at Lightspark. **/
+SIGNET = "SIGNET",
+/** A test version of the Bitcoin Blockchain, publicly available. **/
+TESTNET = "TESTNET",
+
+}
+
+export default BitcoinNetwork;

package/src/graphql/objects/CompleteCoopExitInput.ts

@@ -0,0 +1,41 @@
+
+// Copyright ©, 2023-present, Lightspark Group, Inc. - All Rights Reserved
+
+
+
+
+
+interface CompleteCoopExitInput {
+
+
+    userOutboundTransferExternalId: string;
+
+    coopExitRequestId: string;
+
+
+
+
+}
+
+export const CompleteCoopExitInputFromJson = (obj: any): CompleteCoopExitInput => {
+    return {
+        userOutboundTransferExternalId: obj["complete_coop_exit_input_user_outbound_transfer_external_id"],
+        coopExitRequestId: obj["complete_coop_exit_input_coop_exit_request_id"],
+
+        } as CompleteCoopExitInput;
+
+}
+export const CompleteCoopExitInputToJson = (obj: CompleteCoopExitInput): any => {
+return {
+complete_coop_exit_input_user_outbound_transfer_external_id: obj.userOutboundTransferExternalId,
+complete_coop_exit_input_coop_exit_request_id: obj.coopExitRequestId,
+
+        }
+
+}
+
+
+
+
+
+export default CompleteCoopExitInput;